@renseiai/agentfactory 0.8.0

package/dist/src/logger.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Logger utility for worker and orchestrator output
+ *
+ * Provides colorized, structured logging with worker/agent context.
+ * Uses ANSI escape codes directly to avoid external dependencies.
+ */
+declare const colors: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly brightBlack: "\u001B[90m";
+    readonly brightRed: "\u001B[91m";
+    readonly brightGreen: "\u001B[92m";
+    readonly brightYellow: "\u001B[93m";
+    readonly brightBlue: "\u001B[94m";
+    readonly brightMagenta: "\u001B[95m";
+    readonly brightCyan: "\u001B[96m";
+    readonly brightWhite: "\u001B[97m";
+    readonly bgBlack: "\u001B[40m";
+    readonly bgRed: "\u001B[41m";
+    readonly bgGreen: "\u001B[42m";
+    readonly bgYellow: "\u001B[43m";
+    readonly bgBlue: "\u001B[44m";
+    readonly bgMagenta: "\u001B[45m";
+    readonly bgCyan: "\u001B[46m";
+    readonly bgWhite: "\u001B[47m";
+};
+type ColorName = keyof typeof colors;
+declare const LEVEL_STYLES: Record<string, {
+    color: ColorName;
+    label: string;
+}>;
+export type LogLevel = keyof typeof LEVEL_STYLES;
+export interface LoggerContext {
+    workerId?: string;
+    workerShortId?: string;
+    issueIdentifier?: string;
+    sessionId?: string;
+}
+export interface LoggerOptions {
+    showTimestamp?: boolean;
+    showLevel?: boolean;
+    colorEnabled?: boolean;
+    minLevel?: LogLevel;
+}
+export declare class Logger {
+    private context;
+    private options;
+    constructor(context?: LoggerContext, options?: LoggerOptions);
+    /**
+     * Create a child logger with additional context
+     */
+    child(additionalContext: LoggerContext): Logger;
+    /**
+     * Format the context prefix (worker ID, issue identifier)
+     */
+    private formatPrefix;
+    /**
+     * Format a log line
+     */
+    private formatLine;
+    /**
+     * Format data object for display
+     */
+    private formatData;
+    /**
+     * Check if a log level should be output
+     */
+    private shouldLog;
+    /**
+     * Core log method
+     */
+    private log;
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    success(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Log an activity (thought, action, response) with appropriate styling
+     */
+    activity(type: string, content: string, maxLength?: number): void;
+    /**
+     * Log a section header/divider
+     */
+    section(title: string): void;
+    /**
+     * Log a status change with visual indicator
+     */
+    status(status: string, details?: string): void;
+    /**
+     * Log a tool call with formatted input
+     */
+    toolCall(toolName: string, input?: Record<string, unknown>): void;
+    /**
+     * Format tool input for display (show relevant params based on tool type)
+     */
+    private formatToolInput;
+}
+/**
+ * Create a logger instance
+ */
+export declare function createLogger(context?: LoggerContext, options?: LoggerOptions): Logger;
+/**
+ * Default logger for quick use
+ */
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCF,CAAA;AAEV,KAAK,SAAS,GAAG,MAAM,OAAO,MAAM,CAAA;AAepC,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAMrE,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,YAAY,CAAA;AAEhD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB;AAwCD,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,OAAO,CAAyB;gBAE5B,OAAO,GAAE,aAAkB,EAAE,OAAO,GAAE,aAAkB;IAUpE;;OAEG;IACH,KAAK,CAAC,iBAAiB,EAAE,aAAa,GAAG,MAAM;IAO/C;;OAEG;IACH,OAAO,CAAC,YAAY;IA2BpB;;OAEG;IACH,OAAO,CAAC,UAAU;IA6ClB;;OAEG;IACH,OAAO,CAAC,UAAU;IAiBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,GAAG;IAcX,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI3D,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI3D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI5D;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,SAAK,GAAG,IAAI;IAqC7D;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAa5B;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAoD9C;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAkDjE;;OAEG;IACH,OAAO,CAAC,eAAe;CA0BxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAErF;AAED;;GAEG;AACH,eAAO,MAAM,MAAM,QAAiB,CAAA"}

package/dist/src/logger.js

@@ -0,0 +1,430 @@
+/**
+ * Logger utility for worker and orchestrator output
+ *
+ * Provides colorized, structured logging with worker/agent context.
+ * Uses ANSI escape codes directly to avoid external dependencies.
+ */
+// ANSI color codes
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Foreground colors
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    // Bright foreground colors
+    brightBlack: '\x1b[90m',
+    brightRed: '\x1b[91m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightBlue: '\x1b[94m',
+    brightMagenta: '\x1b[95m',
+    brightCyan: '\x1b[96m',
+    brightWhite: '\x1b[97m',
+    // Background colors
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m',
+};
+// Color palette for worker/agent identification (easy to distinguish)
+const WORKER_COLORS = ['cyan', 'magenta', 'yellow', 'green', 'blue', 'brightCyan', 'brightMagenta', 'brightYellow'];
+// Activity type colors
+const ACTIVITY_COLORS = {
+    thought: 'brightBlack',
+    action: 'blue',
+    response: 'green',
+    tool_use: 'cyan',
+    tool_result: 'brightBlack',
+};
+// Log level styling
+const LEVEL_STYLES = {
+    debug: { color: 'brightBlack', label: 'DBG' },
+    info: { color: 'brightBlue', label: 'INF' },
+    success: { color: 'green', label: 'OK ' },
+    warn: { color: 'yellow', label: 'WRN' },
+    error: { color: 'red', label: 'ERR' },
+};
+const LOG_LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    success: 2,
+    warn: 3,
+    error: 4,
+};
+// Map to track assigned colors for worker/agent IDs
+const colorAssignments = new Map();
+let colorIndex = 0;
+function getColorForId(id) {
+    if (!colorAssignments.has(id)) {
+        colorAssignments.set(id, WORKER_COLORS[colorIndex % WORKER_COLORS.length]);
+        colorIndex++;
+    }
+    return colorAssignments.get(id);
+}
+function colorize(text, ...colorNames) {
+    const colorCodes = colorNames.map((c) => colors[c]).join('');
+    return `${colorCodes}${text}${colors.reset}`;
+}
+function formatTimestamp() {
+    const now = new Date();
+    const hours = now.getHours().toString().padStart(2, '0');
+    const minutes = now.getMinutes().toString().padStart(2, '0');
+    const seconds = now.getSeconds().toString().padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.substring(0, maxLength - 3) + '...';
+}
+export class Logger {
+    context;
+    options;
+    constructor(context = {}, options = {}) {
+        this.context = context;
+        this.options = {
+            showTimestamp: options.showTimestamp ?? true,
+            showLevel: options.showLevel ?? true,
+            colorEnabled: options.colorEnabled ?? process.stdout.isTTY !== false,
+            minLevel: options.minLevel ?? 'info',
+        };
+    }
+    /**
+     * Create a child logger with additional context
+     */
+    child(additionalContext) {
+        return new Logger({ ...this.context, ...additionalContext }, this.options);
+    }
+    /**
+     * Format the context prefix (worker ID, issue identifier)
+     */
+    formatPrefix() {
+        const parts = [];
+        // Worker ID with color
+        if (this.context.workerShortId || this.context.workerId) {
+            const id = this.context.workerShortId || this.context.workerId.substring(0, 8);
+            const color = getColorForId(this.context.workerId || id);
+            if (this.options.colorEnabled) {
+                parts.push(colorize(`[${id}]`, color, 'bold'));
+            }
+            else {
+                parts.push(`[${id}]`);
+            }
+        }
+        // Issue identifier with rotating color for visual distinction
+        if (this.context.issueIdentifier) {
+            if (this.options.colorEnabled) {
+                const color = getColorForId(this.context.issueIdentifier);
+                parts.push(colorize(`[${this.context.issueIdentifier}]`, color, 'bold'));
+            }
+            else {
+                parts.push(`[${this.context.issueIdentifier}]`);
+            }
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Format a log line
+     */
+    formatLine(level, message, data) {
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Level indicator
+        if (this.options.showLevel) {
+            const style = LEVEL_STYLES[level];
+            if (this.options.colorEnabled) {
+                parts.push(colorize(style.label, style.color));
+            }
+            else {
+                parts.push(style.label);
+            }
+        }
+        // Context prefix (worker/issue)
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Message
+        parts.push(message);
+        // Data (if any)
+        if (data && Object.keys(data).length > 0) {
+            const dataStr = this.formatData(data);
+            if (this.options.colorEnabled) {
+                parts.push(colorize(dataStr, 'dim'));
+            }
+            else {
+                parts.push(dataStr);
+            }
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Format data object for display
+     */
+    formatData(data) {
+        const pairs = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined)
+                continue;
+            let valueStr;
+            if (typeof value === 'string') {
+                valueStr = truncate(value, 50);
+            }
+            else if (typeof value === 'number' || typeof value === 'boolean') {
+                valueStr = String(value);
+            }
+            else {
+                valueStr = truncate(JSON.stringify(value), 50);
+            }
+            pairs.push(`${key}=${valueStr}`);
+        }
+        return pairs.length > 0 ? `{ ${pairs.join(', ')} }` : '';
+    }
+    /**
+     * Check if a log level should be output
+     */
+    shouldLog(level) {
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.options.minLevel];
+    }
+    /**
+     * Core log method
+     */
+    log(level, message, data) {
+        if (!this.shouldLog(level))
+            return;
+        const line = this.formatLine(level, message, data);
+        if (level === 'error') {
+            console.error(line);
+        }
+        else if (level === 'warn') {
+            console.warn(line);
+        }
+        else {
+            console.log(line);
+        }
+    }
+    // Convenience methods
+    debug(message, data) {
+        this.log('debug', message, data);
+    }
+    info(message, data) {
+        this.log('info', message, data);
+    }
+    success(message, data) {
+        this.log('success', message, data);
+    }
+    warn(message, data) {
+        this.log('warn', message, data);
+    }
+    error(message, data) {
+        this.log('error', message, data);
+    }
+    /**
+     * Log an activity (thought, action, response) with appropriate styling
+     */
+    activity(type, content, maxLength = 80) {
+        if (!this.shouldLog('info'))
+            return;
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Activity type indicator
+        const activityColor = ACTIVITY_COLORS[type] || 'white';
+        const typeLabel = type.substring(0, 3).toUpperCase();
+        if (this.options.colorEnabled) {
+            parts.push(colorize(typeLabel, activityColor));
+        }
+        else {
+            parts.push(typeLabel);
+        }
+        // Context prefix
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Content (truncated)
+        const truncatedContent = truncate(content.replace(/\n/g, ' '), maxLength);
+        parts.push(truncatedContent);
+        console.log(parts.join(' '));
+    }
+    /**
+     * Log a section header/divider
+     */
+    section(title) {
+        const divider = '─'.repeat(60);
+        if (this.options.colorEnabled) {
+            console.log(colorize(`\n${divider}`, 'dim'));
+            console.log(colorize(`  ${title}`, 'bold', 'brightWhite'));
+            console.log(colorize(`${divider}`, 'dim'));
+        }
+        else {
+            console.log(`\n${divider}`);
+            console.log(`  ${title}`);
+            console.log(divider);
+        }
+    }
+    /**
+     * Log a status change with visual indicator
+     */
+    status(status, details) {
+        const statusColors = {
+            starting: 'yellow',
+            running: 'blue',
+            completed: 'green',
+            stopped: 'yellow',
+            failed: 'red',
+            claimed: 'cyan',
+            registered: 'green',
+        };
+        const color = statusColors[status.toLowerCase()] || 'white';
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Status indicator
+        if (this.options.colorEnabled) {
+            parts.push(colorize('●', color));
+        }
+        else {
+            parts.push('*');
+        }
+        // Context prefix
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Status text
+        if (this.options.colorEnabled) {
+            parts.push(colorize(status.toUpperCase(), color, 'bold'));
+        }
+        else {
+            parts.push(status.toUpperCase());
+        }
+        // Details
+        if (details) {
+            parts.push(details);
+        }
+        console.log(parts.join(' '));
+    }
+    /**
+     * Log a tool call with formatted input
+     */
+    toolCall(toolName, input) {
+        if (!this.shouldLog('info'))
+            return;
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Tool indicator
+        if (this.options.colorEnabled) {
+            parts.push(colorize('→', 'cyan'));
+        }
+        else {
+            parts.push('→');
+        }
+        // Context prefix
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Tool name
+        if (this.options.colorEnabled) {
+            parts.push(colorize(toolName, 'cyan', 'bold'));
+        }
+        else {
+            parts.push(toolName);
+        }
+        // Formatted input (key parameters)
+        if (input) {
+            const summary = this.formatToolInput(toolName, input);
+            if (summary) {
+                if (this.options.colorEnabled) {
+                    parts.push(colorize(summary, 'dim'));
+                }
+                else {
+                    parts.push(summary);
+                }
+            }
+        }
+        console.log(parts.join(' '));
+    }
+    /**
+     * Format tool input for display (show relevant params based on tool type)
+     */
+    formatToolInput(toolName, input) {
+        // Show most relevant parameter based on tool type
+        const toolParams = {
+            Read: ['file_path'],
+            Write: ['file_path'],
+            Edit: ['file_path', 'old_string'],
+            Grep: ['pattern', 'path'],
+            Glob: ['pattern'],
+            Bash: ['command'],
+            Task: ['subagent_type', 'description'],
+            WebFetch: ['url'],
+            WebSearch: ['query'],
+        };
+        const relevantParams = toolParams[toolName] || Object.keys(input).slice(0, 2);
+        const values = [];
+        for (const param of relevantParams) {
+            if (input[param] !== undefined) {
+                const value = String(input[param]);
+                values.push(truncate(value, 40));
+            }
+        }
+        return values.length > 0 ? values.join(' ') : '';
+    }
+}
+/**
+ * Create a logger instance
+ */
+export function createLogger(context, options) {
+    return new Logger(context, options);
+}
+/**
+ * Default logger for quick use
+ */
+export const logger = createLogger();

package/dist/src/manifest/generate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Content generators for route and page files.
+ *
+ * Produces output identical to the create-app templates so that
+ * af-sync-routes can fill in missing files without drift.
+ */
+import type { RouteEntry, PageEntry } from './route-manifest.js';
+/**
+ * Generate the content for a route.ts re-export file.
+ *
+ * Output matches the `routeReexport()` helper in create-app templates.
+ */
+export declare function generateRouteContent(entry: RouteEntry): string;
+/**
+ * Generate the content for a dashboard page.tsx file.
+ *
+ * Output matches the dashboard page helpers in create-app templates.
+ */
+export declare function generatePageContent(entry: PageEntry): string;
+//# sourceMappingURL=generate.d.ts.map

package/dist/src/manifest/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/manifest/generate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEhE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAO9D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CA2C5D"}

package/dist/src/manifest/generate.js

@@ -0,0 +1,65 @@
+/**
+ * Content generators for route and page files.
+ *
+ * Produces output identical to the create-app templates so that
+ * af-sync-routes can fill in missing files without drift.
+ */
+/**
+ * Generate the content for a route.ts re-export file.
+ *
+ * Output matches the `routeReexport()` helper in create-app templates.
+ */
+export function generateRouteContent(entry) {
+    const lines = [`import { routes } from '@/lib/config'`];
+    // Maintain consistent ordering: POST, GET, DELETE
+    if (entry.methods.POST)
+        lines.push(`export const POST = ${entry.methods.POST}`);
+    if (entry.methods.GET)
+        lines.push(`export const GET = ${entry.methods.GET}`);
+    if (entry.methods.DELETE)
+        lines.push(`export const DELETE = ${entry.methods.DELETE}`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * Generate the content for a dashboard page.tsx file.
+ *
+ * Output matches the dashboard page helpers in create-app templates.
+ */
+export function generatePageContent(entry) {
+    const hasParams = entry.params && entry.params.length > 0;
+    // Build import statement
+    const importName = entry.importAlias ?? entry.component;
+    const imports = [`import { DashboardShell, ${importName} } from '@renseiai/agentfactory-dashboard'`];
+    imports.push(`import { usePathname${hasParams ? ', useParams' : ''} } from 'next/navigation'`);
+    // Build component body
+    const bodyLines = [];
+    bodyLines.push(`  const pathname = usePathname()`);
+    if (hasParams) {
+        const paramType = entry.params.map((p) => `${p}: string`).join('; ');
+        bodyLines.push(`  const params = useParams<{ ${paramType} }>()`);
+    }
+    // Build the inner component JSX
+    const componentName = entry.importAlias
+        ? entry.importAlias.split(' as ')[1].trim()
+        : entry.component;
+    let propsStr = '';
+    if (hasParams && entry.propMapping) {
+        const props = Object.entries(entry.propMapping)
+            .map(([param, prop]) => `${prop}={params.${param}}`)
+            .join(' ');
+        propsStr = ` ${props}`;
+    }
+    return `'use client'
+
+${imports.join('\n')}
+
+export default function ${entry.exportName}() {
+${bodyLines.join('\n')}
+  return (
+    <DashboardShell currentPath={pathname}>
+      <${componentName}${propsStr} />
+    </DashboardShell>
+  )
+}
+`;
+}

package/dist/src/manifest/index.d.ts

@@ -0,0 +1,4 @@
+export { ROUTE_MANIFEST } from './route-manifest.js';
+export type { RouteManifest, RouteEntry, PageEntry, HttpMethod } from './route-manifest.js';
+export { generateRouteContent, generatePageContent } from './generate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/manifest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/manifest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC3F,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA"}

package/dist/src/manifest/index.js

@@ -0,0 +1,2 @@
+export { ROUTE_MANIFEST } from './route-manifest.js';
+export { generateRouteContent, generatePageContent } from './generate.js';

package/dist/src/manifest/route-manifest.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Route Manifest — Single source of truth for all AgentFactory route and page files.
+ *
+ * Used by `af-sync-routes` to generate missing route files in consumer projects,
+ * and by parity tests to verify create-app templates stay aligned.
+ */
+export type HttpMethod = 'GET' | 'POST' | 'DELETE';
+export interface RouteEntry {
+    /** Relative file path, e.g. "src/app/api/workers/register/route.ts" */
+    path: string;
+    /** Map of HTTP method → routes accessor, e.g. { POST: 'routes.workers.register.POST' } */
+    methods: Partial<Record<HttpMethod, string>>;
+}
+export interface PageEntry {
+    /** Relative file path, e.g. "src/app/pipeline/page.tsx" */
+    path: string;
+    /** Dashboard component name, e.g. "PipelinePage" */
+    component: string;
+    /** Default export function name, e.g. "Pipeline" */
+    exportName: string;
+    /** Import alias if different from component, e.g. "DashboardPage as FleetPage" */
+    importAlias?: string;
+    /** Dynamic route params, e.g. ["id"] for [id] segments */
+    params?: string[];
+    /** Map of param name → component prop name, e.g. { id: "sessionId" } */
+    propMapping?: Record<string, string>;
+}
+export interface RouteManifest {
+    version: number;
+    routes: RouteEntry[];
+    pages: PageEntry[];
+}
+export declare const ROUTE_MANIFEST: RouteManifest;
+//# sourceMappingURL=route-manifest.d.ts.map

package/dist/src/manifest/route-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-manifest.d.ts","sourceRoot":"","sources":["../../../src/manifest/route-manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;AAElD,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAA;IACZ,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;CAC7C;AAED,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAA;IAClB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB,KAAK,EAAE,SAAS,EAAE,CAAA;CACnB;AAED,eAAO,MAAM,cAAc,EAAE,aAmJ5B,CAAA"}