"generate:editing-flow": "npx tsx scripts/generate-editing-flow.ts",

"build": "npm run generate:toon && npm run generate:editing-flow && npm run build:webview && npm run build:extension",

This file defines the AI editing process flow for workflow refinement.

It is used by the `generate-editing-flow.ts` script to generate TypeScript constants.

1. Review current workflow: Understand ALL existing nodes and their data fields completely

2. Analyze user request: Identify what the user wants

3. Request type check: Is this a question/understanding request OR an edit request?

4. Clarity check: If edit request is vague or ambiguous, return clarification

5. Identify changes: List ONLY the specific nodes/connections that need modification

6. Determine change type: Categorize as add, modify, or delete operation

7. Apply minimal changes: Execute ONLY the identified changes

8. Preserve unchanged: COPY ALL unchanged nodes with their EXACT original data field

9. Output: Return the complete workflow with changes applied

- Questions starting with "What", "Why", "How", "Explain", "Tell me"

- Requests for explanation or clarification about the workflow

- No action verbs like "add", "modify", "delete", "change", "update", "remove"

- Response: Use `{ status: "clarification", message: "your answer" }`

- Contains action verbs: "add", "modify", "delete", "change", "update", "remove", "insert"

- Specifies target node or location

- Describes desired outcome or new content

- Response: Process through steps 4-9, then use `{ status: "success", ... }`

- Vague instructions like "improve", "make better", "fix", "optimize"

- Missing target specification (which node? where?)

- Ambiguous or multiple interpretations possible

- Response: Use `{ status: "clarification", message: "ask for details" }`

- User request does not specify which node to modify

- User request is ambiguous about the desired outcome

- Multiple valid interpretations exist for the request

- Required information (node name, position, content) is missing

- User request conflicts with existing workflow structure

import * as fs from 'node:fs/promises';

import * as path from 'node:path';

const RESOURCES_DIR = path.resolve(__dirname, '../resources');

const MD_PATH = path.join(RESOURCES_DIR, 'ai-editing-process-flow.md');

const OUTPUT_PATH = path.resolve(

__dirname,

'../src/extension/services/editing-flow-constants.generated.ts'

interface EditingFlowData {

mermaidDiagram: string;

steps: string[];

requestTypeGuidelines: {

questionOrUnderstanding: string[];

editRequest: string[];

unclearRequest: string[];

};

clarificationTriggers: string[];

function extractMermaidDiagram(content: string): string {

const match = content.match(/```mermaid\n([\s\S]*?)```/);

if (!match) {

throw new Error('Mermaid diagram not found in markdown file');

}

return match[1].trim();

function extractNumberedList(content: string, heading: string): string[] {

const headingRegex = new RegExp(`## ${heading}\\n\\n([\\s\\S]*?)(?=\\n## |$)`);

const match = content.match(headingRegex);

if (!match) {

return [];

}

const section = match[1];

const items: string[] = [];

const lines = section.split('\n');

for (const line of lines) {

const numberedMatch = line.match(/^\d+\.\s+(.+)$/);

if (numberedMatch) {

items.push(numberedMatch[1].trim());

}

}

return items;

function extractBulletList(content: string, mainHeading: string, subHeading: string): string[] {

// Find the main section

const mainRegex = new RegExp(`## ${mainHeading}\\n\\n([\\s\\S]*?)(?=\\n## [^#]|$)`);

const mainMatch = content.match(mainRegex);

if (!mainMatch) {

return [];

}

const mainSection = mainMatch[1];

// Find the subsection

const subRegex = new RegExp(`### ${subHeading}\\n\\n([\\s\\S]*?)(?=\\n### |$)`);

const subMatch = mainSection.match(subRegex);

if (!subMatch) {

return [];

}

const subSection = subMatch[1];

const items: string[] = [];

const lines = subSection.split('\n');

for (const line of lines) {

const bulletMatch = line.match(/^-\s+(.+)$/);

if (bulletMatch) {

// Remove backticks from inline code

items.push(bulletMatch[1].trim().replace(/`/g, ''));

}

}

return items;

function extractTopLevelBulletList(content: string, heading: string): string[] {

const headingRegex = new RegExp(`## ${heading}\\n\\n([\\s\\S]*?)(?=\\n## |$)`);

const match = content.match(headingRegex);

if (!match) {

return [];

}

const section = match[1];

const items: string[] = [];

const lines = section.split('\n');

for (const line of lines) {

const bulletMatch = line.match(/^-\s+(.+)$/);

if (bulletMatch) {

items.push(bulletMatch[1].trim());

}

}

return items;

function parseMarkdown(content: string): EditingFlowData {

return {

mermaidDiagram: extractMermaidDiagram(content),

steps: extractNumberedList(content, 'Process Steps'),

requestTypeGuidelines: {

questionOrUnderstanding: extractBulletList(

content,

'Request Type Guidelines',

'Question or Understanding Request'

),

editRequest: extractBulletList(content, 'Request Type Guidelines', 'Edit Request'),

unclearRequest: extractBulletList(content, 'Request Type Guidelines', 'Unclear Request'),

},

clarificationTriggers: extractTopLevelBulletList(content, 'Clarification Triggers'),

};

function generateTypeScript(data: EditingFlowData): string {

const toStringArray = (arr: string[]) =>

arr.map((item) => ` '${item.replace(/'/g, "\\'")}',`).join('\n');

return `/**

async function generateEditingFlow(): Promise<void> {

console.log('Generating editing flow constants from ai-editing-process-flow.md...');

try {

// Read markdown file

const mdContent = await fs.readFile(MD_PATH, 'utf-8');

// Parse markdown

const data = parseMarkdown(mdContent);

// Generate TypeScript

const tsContent = generateTypeScript(data);

// Write output file

await fs.writeFile(OUTPUT_PATH, tsContent, 'utf-8');

console.log('Editing flow constants generated successfully:');

console.log(` Source: ${path.relative(process.cwd(), MD_PATH)}`);

console.log(` Output: ${path.relative(process.cwd(), OUTPUT_PATH)}`);

console.log(` Steps: ${data.steps.length}`);

console.log(` Clarification triggers: ${data.clarificationTriggers.length}`);

} catch (error) {

console.error('Failed to generate editing flow constants:', error);

process.exit(1);

}