@synergenius/flow-weaver 0.15.2 → 0.17.0

package/dist/cli/commands/compile.js

@@ -14,6 +14,15 @@ import { getFriendlyError } from '../../friendly-errors.js';
 import { detectProjectModuleFormat } from './doctor.js';
 import { generateInngestFunction } from '../../generator/inngest.js';
 import { AnnotationParser } from '../../parser.js';
+/** Show path relative to cwd for cleaner output */
+function displayPath(filePath) {
+    const rel = path.relative(process.cwd(), filePath);
+    // Use relative if it's shorter and doesn't escape cwd
+    if (rel && !rel.startsWith('..') && rel.length < filePath.length) {
+        return rel;
+    }
+    return filePath;
+}
 /**
  * Resolve the module format to use for compilation.
  * If 'auto' or not specified, detect from the project's package.json.
@@ -35,181 +44,181 @@ export async function compileCommand(input, options = {}) {
     // Resolve module format (auto-detect if not specified)
     const cwd = process.cwd();
     const moduleFormat = resolveModuleFormat(format, cwd);
+    // If input is a directory, expand to all .ts files recursively
+    let pattern = input;
     try {
-        // If input is a directory, expand to all .ts files recursively
-        let pattern = input;
+        if (fs.existsSync(input) && fs.statSync(input).isDirectory()) {
+            pattern = path.join(input, '**/*.ts');
+        }
+    }
+    catch {
+        // Not a valid path, use as glob pattern
+    }
+    // Find files matching the pattern, filter to actual files only
+    const allFiles = await glob(pattern, { absolute: true });
+    const files = allFiles.filter((f) => {
         try {
-            if (fs.existsSync(input) && fs.statSync(input).isDirectory()) {
-                pattern = path.join(input, '**/*.ts');
-            }
+            return fs.statSync(f).isFile();
         }
         catch {
-            // Not a valid path, use as glob pattern
+            return false;
         }
-        // Find files matching the pattern, filter to actual files only
-        const allFiles = await glob(pattern, { absolute: true });
-        const files = allFiles.filter((f) => {
-            try {
-                return fs.statSync(f).isFile();
-            }
-            catch {
-                return false;
-            }
-        });
-        if (files.length === 0) {
-            throw new Error(`No files found matching pattern: ${input}`);
-        }
-        logger.section('Compiling Workflows');
+    });
+    if (files.length === 0) {
+        throw new Error(`No files found matching pattern: ${input}`);
+    }
+    const totalTimer = logger.timer();
+    logger.section('Compiling Workflows');
+    if (verbose) {
         logger.info(`Found ${files.length} file(s)`);
         logger.info(`Module format: ${moduleFormat.toUpperCase()}`);
         if (sourceMap) {
             logger.info('Source maps: enabled');
         }
-        if (verbose) {
-            files.forEach((file) => logger.info(`  - ${file}`));
-        }
+        files.forEach((file) => logger.info(`  ${displayPath(file)}`));
         logger.newline();
-        let successCount = 0;
-        let errorCount = 0;
-        for (let i = 0; i < files.length; i++) {
-            const file = files[i];
-            const fileName = path.basename(file);
-            logger.progress(i + 1, files.length, fileName);
-            try {
-                // Skip files without @flowWeaver annotations before parsing
-                const rawSource = fs.readFileSync(file, 'utf8');
-                if (!rawSource.includes('@flowWeaver')) {
-                    if (verbose) {
-                        logger.info(`  Skipped ${fileName} (no @flowWeaver annotations)`);
-                    }
-                    continue;
-                }
-                // Parse the workflow
-                const parseResult = await parseWorkflow(file, { workflowName });
-                if (parseResult.warnings.length > 0) {
-                    parseResult.warnings.forEach((w) => logger.warn(`  ${w}`));
+    }
+    let successCount = 0;
+    let errorCount = 0;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const fileName = path.basename(file);
+        const fileTimer = logger.timer();
+        try {
+            // Skip files without @flowWeaver annotations before parsing
+            const rawSource = fs.readFileSync(file, 'utf8');
+            if (!rawSource.includes('@flowWeaver')) {
+                if (verbose) {
+                    logger.info(`  ${logger.dim('skip')} ${fileName} ${logger.dim('(no @flowWeaver annotations)')}`);
                 }
-                if (parseResult.errors.length > 0) {
-                    // Skip non-workflow files silently (only error is "No workflows found")
-                    const isNonWorkflowFile = parseResult.errors.length === 1 &&
-                        typeof parseResult.errors[0] === 'string' &&
-                        parseResult.errors[0].startsWith('No workflows found');
-                    if (isNonWorkflowFile) {
-                        if (verbose) {
-                            logger.info(`  Skipped ${fileName} (no workflow)`);
-                        }
-                        continue;
+                continue;
+            }
+            // Parse the workflow
+            const parseResult = await parseWorkflow(file, { workflowName });
+            if (parseResult.warnings.length > 0 && verbose) {
+                logger.warn(`Parse warnings in ${fileName}:`);
+                parseResult.warnings.forEach((w) => logger.warn(`  ${w}`));
+            }
+            if (parseResult.errors.length > 0) {
+                // Skip non-workflow files silently (only error is "No workflows found")
+                const isNonWorkflowFile = parseResult.errors.length === 1 &&
+                    typeof parseResult.errors[0] === 'string' &&
+                    parseResult.errors[0].startsWith('No workflows found');
+                if (isNonWorkflowFile) {
+                    if (verbose) {
+                        logger.info(`  ${logger.dim('skip')} ${fileName} ${logger.dim('(no workflow)')}`);
                     }
-                    logger.error(`Failed to parse ${fileName}:`);
-                    parseResult.errors.forEach((err) => logger.error(`  ${err}`));
-                    errorCount++;
                     continue;
                 }
-                // Validate the AST (especially for --strict mode)
-                if (strict) {
-                    const validation = validator.validate(parseResult.ast, { strictMode: true });
-                    if (validation.errors.length > 0) {
-                        logger.error(`Validation errors in ${fileName}:`);
-                        validation.errors.forEach((err) => {
-                            const friendly = getFriendlyError(err);
-                            if (friendly) {
-                                const loc = err.location ? `[line ${err.location.line}] ` : '';
-                                logger.error(`  ${loc}${friendly.title}: ${friendly.explanation}`);
-                                logger.info(`    How to fix: ${friendly.fix}`);
-                                if (err.docUrl) {
-                                    logger.info(`    See: ${err.docUrl}`);
-                                }
-                            }
-                            else {
-                                let msg = `  - ${err.message}`;
-                                if (err.node) {
-                                    msg += ` (node: ${err.node})`;
-                                }
-                                logger.error(msg);
-                                if (err.docUrl) {
-                                    logger.info(`    See: ${err.docUrl}`);
-                                }
+                logger.error(`  ${fileName}`);
+                parseResult.errors.forEach((err) => logger.error(`    ${err}`));
+                errorCount++;
+                continue;
+            }
+            // Validate the AST (especially for --strict mode)
+            if (strict) {
+                const validation = validator.validate(parseResult.ast, { strictMode: true });
+                if (validation.errors.length > 0) {
+                    logger.error(`  ${fileName}`);
+                    validation.errors.forEach((err) => {
+                        const friendly = getFriendlyError(err);
+                        if (friendly) {
+                            const loc = err.location ? `[line ${err.location.line}] ` : '';
+                            logger.error(`    ${loc}${friendly.title}: ${friendly.explanation}`);
+                            logger.warn(`    How to fix: ${friendly.fix}`);
+                            if (err.docUrl) {
+                                logger.warn(`    See: ${err.docUrl}`);
                             }
-                        });
-                        errorCount++;
-                        continue;
-                    }
-                    if (validation.warnings.length > 0 && verbose) {
-                        validation.warnings.forEach((warn) => {
-                            const friendly = getFriendlyError(warn);
-                            if (friendly) {
-                                const loc = warn.location ? `[line ${warn.location.line}] ` : '';
-                                logger.warn(`  ${loc}${friendly.title}: ${friendly.explanation}`);
-                                logger.info(`    How to fix: ${friendly.fix}`);
+                        }
+                        else {
+                            let msg = `    ${err.message}`;
+                            if (err.node) {
+                                msg += ` (node: ${err.node})`;
                             }
-                            else {
-                                logger.warn(`  ${warn.message}`);
+                            logger.error(msg);
+                            if (err.docUrl) {
+                                logger.warn(`    See: ${err.docUrl}`);
                             }
-                        });
-                    }
+                        }
+                    });
+                    errorCount++;
+                    continue;
                 }
-                // Read original source
-                const sourceCode = fs.readFileSync(file, 'utf8');
-                // Generate code in-place (preserves types, interfaces, etc.)
-                const result = generateInPlace(sourceCode, parseResult.ast, { production, moduleFormat, inlineRuntime, sourceFile: file, skipParamReturns: clean });
-                // Write back to original file (skip in dry-run mode)
-                if (!dryRun) {
-                    fs.writeFileSync(file, result.code, 'utf8');
-                    // Generate source map if requested
-                    if (sourceMap) {
-                        const mapResult = generateCode(parseResult.ast, {
-                            production,
-                            sourceMap: true,
-                            moduleFormat,
-                        });
-                        if (mapResult.sourceMap) {
-                            const mapPath = file + '.map';
-                            fs.writeFileSync(mapPath, mapResult.sourceMap, 'utf8');
-                            // Append sourceMappingURL comment to the compiled file
-                            const sourceMappingComment = `\n//# sourceMappingURL=${path.basename(mapPath)}\n`;
-                            if (!result.code.includes('//# sourceMappingURL=')) {
-                                fs.appendFileSync(file, sourceMappingComment, 'utf8');
-                            }
-                            if (verbose) {
-                                logger.info(`  Source map: ${mapPath}`);
-                            }
+                if (validation.warnings.length > 0 && verbose) {
+                    validation.warnings.forEach((warn) => {
+                        const friendly = getFriendlyError(warn);
+                        if (friendly) {
+                            const loc = warn.location ? `[line ${warn.location.line}] ` : '';
+                            logger.warn(`  ${loc}${friendly.title}: ${friendly.explanation}`);
+                            logger.warn(`    How to fix: ${friendly.fix}`);
                         }
-                    }
+                        else {
+                            logger.warn(`  ${warn.message}`);
+                        }
+                    });
                 }
-                if (dryRun) {
-                    if (result.hasChanges) {
-                        logger.success(`  Would compile: ${file}`);
-                    }
-                    else if (verbose) {
-                        logger.info(`  No changes: ${file}`);
+            }
+            // Read original source
+            const sourceCode = fs.readFileSync(file, 'utf8');
+            // Generate code in-place (preserves types, interfaces, etc.)
+            const result = generateInPlace(sourceCode, parseResult.ast, { production, moduleFormat, inlineRuntime, sourceFile: file, skipParamReturns: clean });
+            // Write back to original file (skip in dry-run mode)
+            if (!dryRun) {
+                fs.writeFileSync(file, result.code, 'utf8');
+                // Generate source map if requested
+                if (sourceMap) {
+                    const mapResult = generateCode(parseResult.ast, {
+                        production,
+                        sourceMap: true,
+                        moduleFormat,
+                    });
+                    if (mapResult.sourceMap) {
+                        const mapPath = file + '.map';
+                        fs.writeFileSync(mapPath, mapResult.sourceMap, 'utf8');
+                        const sourceMappingComment = `\n//# sourceMappingURL=${path.basename(mapPath)}\n`;
+                        if (!result.code.includes('//# sourceMappingURL=')) {
+                            fs.appendFileSync(file, sourceMappingComment, 'utf8');
+                        }
+                        if (verbose) {
+                            logger.info(`    source map: ${displayPath(mapPath)}`);
+                        }
                     }
                 }
-                else if (result.hasChanges) {
-                    logger.success(`  Compiled: ${file}`);
+            }
+            const timing = logger.dim(fileTimer.elapsed());
+            const filePrint = displayPath(file);
+            if (dryRun) {
+                if (result.hasChanges) {
+                    logger.success(`${filePrint} ${timing} ${logger.dim('(dry run)')}`);
                 }
-                else if (verbose) {
-                    logger.info(`  No changes: ${file}`);
+                else {
+                    logger.log(`  ${filePrint} ${logger.dim('(no changes, dry run)')}`);
                 }
-                successCount++;
             }
-            catch (error) {
-                logger.error(`Failed to compile ${fileName}: ${getErrorMessage(error)}`);
-                errorCount++;
+            else if (result.hasChanges) {
+                logger.success(`${filePrint} ${timing}`);
             }
+            else if (verbose) {
+                logger.info(`  ${filePrint} ${logger.dim('no changes')}`);
+            }
+            successCount++;
         }
-        // Summary
-        logger.newline();
-        logger.section('Summary');
-        logger.success(`${successCount} file(s) compiled successfully`);
-        if (errorCount > 0) {
-            throw new Error(`${errorCount} file(s) failed to compile`);
+        catch (error) {
+            logger.error(`  ${fileName}: ${getErrorMessage(error)}`);
+            errorCount++;
         }
     }
-    catch (error) {
-        if (error instanceof Error && error.message.includes('file(s) failed')) {
-            throw error;
-        }
-        throw new Error(`Compilation failed: ${getErrorMessage(error)}`);
+    // Summary
+    const elapsed = totalTimer.elapsed();
+    const formatNote = verbose ? '' : ` (${moduleFormat.toUpperCase()})`;
+    const dryRunNote = dryRun ? ' (dry run)' : '';
+    logger.newline();
+    if (errorCount > 0) {
+        logger.log(`  ${successCount} compiled, ${errorCount} failed${formatNote} in ${elapsed}${dryRunNote}`);
+        throw new Error(`${errorCount} file(s) failed to compile`);
+    }
+    else {
+        logger.log(`  ${successCount} file${successCount !== 1 ? 's' : ''} compiled${formatNote} in ${elapsed}${dryRunNote}`);
     }
 }
 /**
@@ -218,10 +227,10 @@ export async function compileCommand(input, options = {}) {
 export async function compileInngestTarget(input, options) {
     const filePath = path.resolve(input);
     if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
+        throw new Error(`File not found: ${displayPath(filePath)}`);
     }
     logger.section('Compiling to Inngest');
-    logger.info(`Input: ${filePath}`);
+    logger.info(`Input: ${displayPath(filePath)}`);
     logger.info(`Target: Inngest (per-node step.run)`);
     logger.newline();
     const parser = new AnnotationParser();
@@ -262,7 +271,7 @@ export async function compileInngestTarget(input, options) {
     });
     const outputPath = filePath.replace(/\.ts$/, '.inngest.ts');
     if (options.dryRun) {
-        logger.success(`Would generate: ${outputPath}`);
+        logger.success(`Would generate: ${displayPath(outputPath)}`);
         logger.newline();
         logger.section('Preview');
         const lines = code.split('\n');
@@ -274,7 +283,7 @@ export async function compileInngestTarget(input, options) {
     }
     else {
         fs.writeFileSync(outputPath, code, 'utf8');
-        logger.success(`Compiled: ${outputPath}`);
+        logger.success(`Compiled: ${displayPath(outputPath)}`);
     }
     logger.newline();
     logger.section('Summary');

package/dist/cli/commands/dev.js

@@ -16,7 +16,15 @@ function timestamp() {
     const h = String(now.getHours()).padStart(2, '0');
     const m = String(now.getMinutes()).padStart(2, '0');
     const s = String(now.getSeconds()).padStart(2, '0');
-    return `[${h}:${m}:${s}]`;
+    return `${h}:${m}:${s}`;
+}
+function cycleSeparator(file) {
+    const ts = timestamp();
+    const pad = '─'.repeat(40);
+    logger.log(`\n  ${logger.dim(`─── ${ts} ${pad}`)}`);
+    if (file) {
+        logger.log(`  ${logger.dim('File changed:')} ${path.basename(file)}`);
+    }
 }
 /**
  * Parse params from --params or --params-file.
@@ -56,9 +64,10 @@ async function compileAndRun(filePath, params, options) {
         clean: options.clean,
     };
     try {
+        const ct = logger.timer();
         await compileCommand(filePath, compileOpts);
         if (!options.json) {
-            logger.success('Compiled successfully');
+            logger.success(`Compiled in ${ct.elapsed()}`);
         }
     }
     catch (error) {
@@ -70,7 +79,7 @@ async function compileAndRun(filePath, params, options) {
                 const friendly = getFriendlyError(err);
                 if (friendly) {
                     logger.error(`  ${friendly.title}: ${friendly.explanation}`);
-                    logger.info(`    How to fix: ${friendly.fix}`);
+                    logger.warn(`    How to fix: ${friendly.fix}`);
                 }
                 else {
                     logger.error(`  - ${err.message}`);
@@ -99,8 +108,6 @@ async function compileAndRun(filePath, params, options) {
         }
         else {
             logger.success(`Workflow "${result.functionName}" completed in ${result.executionTime}ms`);
-            logger.newline();
-            logger.section('Result');
             logger.log(JSON.stringify(result.result, null, 2));
         }
         return true;
@@ -286,10 +293,8 @@ async function runInngestDevMode(filePath, options) {
         ignoreInitial: true,
     });
     watcher.on('change', async (file) => {
-        logger.newline();
-        logger.info(`${timestamp()} File changed: ${path.basename(file)}`);
+        cycleSeparator(file);
         logger.info('Recompiling and restarting server...');
-        logger.newline();
         await restartServer();
     });
     // Cleanup
@@ -360,9 +365,7 @@ export async function devCommand(input, options = {}) {
     });
     watcher.on('change', async (file) => {
         if (!options.json) {
-            logger.newline();
-            logger.info(`${timestamp()} File changed: ${path.basename(file)}`);
-            logger.newline();
+            cycleSeparator(file);
         }
         await compileAndRun(filePath, params, options);
     });

package/dist/cli/commands/diff.js

@@ -40,7 +40,12 @@ export async function diffCommand(file1, file2, options = {}) {
         const diff = WorkflowDiffer.compare(result1.ast, result2.ast);
         // Output based on format
         if (diff.identical) {
-            logger.success('Workflows are identical');
+            if (format === 'json') {
+                console.log(JSON.stringify({ identical: true }));
+            }
+            else {
+                logger.success('Workflows are identical');
+            }
         }
         else {
             // eslint-disable-next-line no-console

package/dist/cli/commands/doctor.js

@@ -669,37 +669,28 @@ export async function doctorCommand(options = {}) {
     }
     else {
         logger.section('Flow Weaver Doctor');
-        logger.info(`Checking project at ${cwd}`);
-        logger.newline();
-        for (const check of report.checks) {
-            switch (check.status) {
-                case 'pass':
-                    logger.success(check.message);
-                    break;
-                case 'warn':
-                    logger.warn(check.message);
-                    if (check.fix) {
-                        logger.log(`    Fix: ${check.fix}`);
-                    }
-                    break;
-                case 'fail':
-                    logger.error(check.message);
-                    if (check.fix) {
-                        logger.log(`    Fix: ${check.fix}`);
-                    }
-                    break;
+        const statusIcon = (s) => s === 'pass' ? logger.highlight('pass') : s === 'warn' ? '⚠ warn' : '✗ fail';
+        const rows = report.checks.map((check) => [
+            check.name,
+            check.message,
+            statusIcon(check.status),
+        ]);
+        logger.table(rows);
+        // Show fixes for non-passing checks
+        const fixable = report.checks.filter((c) => c.status !== 'pass' && c.fix);
+        if (fixable.length > 0) {
+            logger.newline();
+            for (const check of fixable) {
+                logger.log(`  ${logger.dim(check.name + ':')} ${check.fix}`);
             }
         }
         logger.newline();
-        logger.section('Module Format');
-        logger.info(`  Detected: ${report.moduleFormat.format.toUpperCase()} (${report.moduleFormat.details})`);
-        logger.newline();
-        logger.section('Summary');
+        logger.log(`  Module format: ${report.moduleFormat.format.toUpperCase()} ${logger.dim(`(${report.moduleFormat.details})`)}`);
         const parts = [];
         if (report.summary.pass > 0)
             parts.push(`${report.summary.pass} passed`);
         if (report.summary.warn > 0)
-            parts.push(`${report.summary.warn} warning(s)`);
+            parts.push(`${report.summary.warn} warnings`);
         if (report.summary.fail > 0)
             parts.push(`${report.summary.fail} failed`);
         logger.log(`  ${parts.join(', ')}`);
@@ -709,7 +700,7 @@ export async function doctorCommand(options = {}) {
         }
         else {
             logger.newline();
-            logger.error('Some checks failed. Please fix the issues above.');
+            logger.error('Fix the issues above to continue.');
         }
     }
     if (!report.ok) {

package/dist/cli/commands/export.js

@@ -39,6 +39,7 @@ export async function exportCommand(input, options) {
         throw new Error('--target is required. Install a target pack (e.g. npm install flowweaver-pack-lambda)');
     }
     const isDryRun = options.dryRun ?? false;
+    const t = logger.timer();
     const isMulti = options.multi ?? false;
     const workflowsList = options.workflows
         ? options.workflows.split(',').map((w) => w.trim())
@@ -98,6 +99,7 @@ export async function exportCommand(input, options) {
         else {
             logger.success(`Exported workflow "${result.workflow}" for ${result.target}`);
         }
+        logger.info(`done in ${t.elapsed()}`);
     }
     logger.newline();
     logger.section(isDryRun ? 'Files That Would Be Generated' : 'Generated Files');

package/dist/cli/commands/grammar.js

@@ -6,7 +6,9 @@ import { generateGrammarDiagrams, getAllGrammars, serializedToEBNF, } from '../.
 import { logger } from '../utils/logger.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
 export async function grammarCommand(options = {}) {
-    const { format = 'html', output } = options;
+    // Default to ebnf on TTY (readable in terminal), html when writing to file
+    const defaultFormat = options.output ? 'html' : (process.stdout.isTTY ? 'ebnf' : 'html');
+    const { format = defaultFormat, output } = options;
     try {
         let content;
         if (format === 'ebnf') {

package/dist/cli/commands/init-personas.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Persona-specific logic for the init command.
+ * Types, use-case mappings, template selection, and post-scaffold output.
+ */
+export type PersonaId = 'nocode' | 'vibecoder' | 'lowcode' | 'expert';
+export type UseCaseId = 'data' | 'ai' | 'api' | 'automation' | 'cicd' | 'minimal';
+export declare const PERSONA_CHOICES: {
+    value: PersonaId;
+    name: string;
+    description: string;
+}[];
+/** One-liner printed after persona selection to set expectations. null = skip. */
+export declare const PERSONA_CONFIRMATIONS: Record<PersonaId, string | null>;
+export declare const USE_CASE_CHOICES: {
+    value: UseCaseId;
+    name: string;
+    description: string;
+}[];
+export interface UseCaseMapping {
+    default: string;
+    all: string[];
+}
+export declare const USE_CASE_TEMPLATES: Record<UseCaseId, UseCaseMapping>;
+/**
+ * Select the template for a given persona and use-case.
+ * For lowcode, returns the full list when the category has multiple templates.
+ * For nocode/vibecoder, always returns the single default.
+ */
+export declare function selectTemplateForPersona(persona: PersonaId, useCase: UseCaseId): {
+    template: string;
+    choices?: string[];
+};
+/**
+ * Build the template sub-choice list for inquirer, when lowcode needs to pick
+ * from multiple templates within a use-case category.
+ */
+export declare function getTemplateSubChoices(templateIds: string[]): Array<{
+    value: string;
+    name: string;
+    description: string;
+}>;
+/**
+ * Extract @path annotations from generated workflow code and format as a
+ * visual flow line. Falls back to extracting @node labels if no @path found.
+ */
+export declare function extractWorkflowPreview(workflowCode: string): string | null;
+export declare const FILE_DESCRIPTIONS: Record<string, string>;
+export declare function generateReadme(projectName: string, persona: PersonaId, _template: string): string;
+export declare function generateExampleWorkflow(projectName: string): string;
+export interface PrintNextStepsOptions {
+    projectName: string;
+    persona: PersonaId;
+    template: string;
+    displayDir: string | null;
+    installSkipped: boolean;
+    workflowCode: string | null;
+    workflowFile: string;
+    mcpConfigured?: string[];
+    /** When true, skip persona-specific guidance (the agent handles it) */
+    agentLaunched?: boolean;
+}
+export declare function printNextSteps(opts: PrintNextStepsOptions): void;
+/** Maps each persona to the fw_context preset used for agent knowledge bootstrap. */
+export declare const AGENT_CONTEXT_PRESETS: Record<PersonaId, string>;
+/**
+ * Generate the initial prompt for a CLI agent (Claude Code, Codex).
+ * Interpolates project name and template into the persona-specific template.
+ */
+export declare function generateAgentPrompt(projectName: string, persona: PersonaId, template: string): string;
+/**
+ * Generate a shorter prompt suitable for pasting into a GUI editor.
+ * Persona-aware but more concise than the full agent prompt.
+ */
+export declare function generateEditorPrompt(projectName: string, persona: PersonaId, template: string): string;
+/**
+ * Generate the full content for a PROJECT_SETUP.md file.
+ * Includes the agent prompt plus project context.
+ */
+export declare function generateSetupPromptFile(projectName: string, persona: PersonaId, template: string, filesCreated: string[]): string;
+/**
+ * Print a copyable prompt in a bordered box.
+ * Long lines are word-wrapped to fit within the box.
+ */
+export declare function printCopyablePrompt(prompt: string): void;
+/** Default for the "Launch agent?" confirm prompt per persona */
+export declare const AGENT_LAUNCH_DEFAULTS: Record<PersonaId, boolean>;
+//# sourceMappingURL=init-personas.d.ts.map