@renseiai/agentfactory 0.8.0

package/dist/src/manifest/route-manifest.js

@@ -0,0 +1,148 @@
+/**
+ * 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 const ROUTE_MANIFEST = {
+    version: 1,
+    routes: [
+        // Webhook & OAuth
+        {
+            path: 'src/app/webhook/route.ts',
+            methods: { POST: 'routes.webhook.POST', GET: 'routes.webhook.GET' },
+        },
+        {
+            path: 'src/app/callback/route.ts',
+            methods: { GET: 'routes.oauth.callback.GET' },
+        },
+        // Worker routes
+        {
+            path: 'src/app/api/workers/register/route.ts',
+            methods: { POST: 'routes.workers.register.POST' },
+        },
+        {
+            path: 'src/app/api/workers/route.ts',
+            methods: { GET: 'routes.workers.list.GET' },
+        },
+        {
+            path: 'src/app/api/workers/[id]/route.ts',
+            methods: { GET: 'routes.workers.detail.GET', DELETE: 'routes.workers.detail.DELETE' },
+        },
+        {
+            path: 'src/app/api/workers/[id]/heartbeat/route.ts',
+            methods: { POST: 'routes.workers.heartbeat.POST' },
+        },
+        {
+            path: 'src/app/api/workers/[id]/poll/route.ts',
+            methods: { GET: 'routes.workers.poll.GET' },
+        },
+        // Session routes
+        {
+            path: 'src/app/api/sessions/route.ts',
+            methods: { GET: 'routes.sessions.list.GET' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/route.ts',
+            methods: { GET: 'routes.sessions.detail.GET' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/claim/route.ts',
+            methods: { POST: 'routes.sessions.claim.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/status/route.ts',
+            methods: { POST: 'routes.sessions.status.POST', GET: 'routes.sessions.status.GET' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/lock-refresh/route.ts',
+            methods: { POST: 'routes.sessions.lockRefresh.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/prompts/route.ts',
+            methods: { POST: 'routes.sessions.prompts.POST', GET: 'routes.sessions.prompts.GET' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/transfer-ownership/route.ts',
+            methods: { POST: 'routes.sessions.transferOwnership.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/activity/route.ts',
+            methods: { POST: 'routes.sessions.activity.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/completion/route.ts',
+            methods: { POST: 'routes.sessions.completion.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/external-urls/route.ts',
+            methods: { POST: 'routes.sessions.externalUrls.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/progress/route.ts',
+            methods: { POST: 'routes.sessions.progress.POST' },
+        },
+        {
+            path: 'src/app/api/sessions/[id]/tool-error/route.ts',
+            methods: { POST: 'routes.sessions.toolError.POST' },
+        },
+        // Public routes
+        {
+            path: 'src/app/api/public/stats/route.ts',
+            methods: { GET: 'routes.public.stats.GET' },
+        },
+        {
+            path: 'src/app/api/public/sessions/route.ts',
+            methods: { GET: 'routes.public.sessions.GET' },
+        },
+        {
+            path: 'src/app/api/public/sessions/[id]/route.ts',
+            methods: { GET: 'routes.public.sessionDetail.GET' },
+        },
+        // Config route
+        {
+            path: 'src/app/api/config/route.ts',
+            methods: { GET: 'routes.config.GET' },
+        },
+        // Cleanup route
+        {
+            path: 'src/app/api/cleanup/route.ts',
+            methods: { POST: 'routes.cleanup.POST', GET: 'routes.cleanup.GET' },
+        },
+        // Issue tracker proxy (centralized API gateway for agents/governors)
+        {
+            path: 'src/app/api/issue-tracker-proxy/route.ts',
+            methods: { POST: 'routes.issueTrackerProxy.POST', GET: 'routes.issueTrackerProxy.GET' },
+        },
+    ],
+    pages: [
+        {
+            path: 'src/app/page.tsx',
+            component: 'DashboardPage',
+            exportName: 'DashboardPage',
+            importAlias: 'DashboardPage as FleetPage',
+        },
+        {
+            path: 'src/app/pipeline/page.tsx',
+            component: 'PipelinePage',
+            exportName: 'Pipeline',
+        },
+        {
+            path: 'src/app/sessions/page.tsx',
+            component: 'SessionPage',
+            exportName: 'Sessions',
+        },
+        {
+            path: 'src/app/sessions/[id]/page.tsx',
+            component: 'SessionPage',
+            exportName: 'SessionDetailPage',
+            params: ['id'],
+            propMapping: { id: 'sessionId' },
+        },
+        {
+            path: 'src/app/settings/page.tsx',
+            component: 'SettingsPage',
+            exportName: 'Settings',
+        },
+    ],
+};

package/dist/src/orchestrator/activity-emitter.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Linear Activity Emitter
+ *
+ * Emits Claude stream events to Linear as agent activities.
+ * Handles rate limiting by batching rapid activities and
+ * truncating long outputs.
+ *
+ * Mapping:
+ * - assistant message → response (persisted, user-directed communication)
+ * - tool_use → action (ephemeral)
+ * - tool_result → action (ephemeral)
+ * - result → response (persisted)
+ * - error → error (persisted)
+ */
+import type { AgentSession } from '@renseiai/agentfactory-linear';
+/** Configuration for the activity emitter */
+export interface ActivityEmitterConfig {
+    /** AgentSession to emit activities to */
+    session: AgentSession;
+    /** Minimum interval between activities in ms (default: 500ms) */
+    minInterval?: number;
+    /** Maximum length for tool outputs before truncation (default: 2000) */
+    maxOutputLength?: number;
+    /** Whether to include timestamps in activities (default: false) */
+    includeTimestamps?: boolean;
+    /** Optional callback when an activity is emitted */
+    onActivityEmitted?: (type: string, content: string) => void;
+    /** Optional callback when an activity is throttled */
+    onActivityThrottled?: (type: string, content: string) => void;
+}
+/**
+ * Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear activities.
+ */
+export declare class ActivityEmitter {
+    private readonly session;
+    private readonly minInterval;
+    private readonly maxOutputLength;
+    private readonly includeTimestamps;
+    private readonly onActivityEmitted?;
+    private readonly onActivityThrottled?;
+    private lastEmitTime;
+    private queue;
+    private flushTimer;
+    private isProcessing;
+    private readonly reportedToolErrors;
+    constructor(config: ActivityEmitterConfig);
+    /**
+     * Emit a thought activity (persistent by default for visibility in Linear)
+     */
+    emitThought(content: string, ephemeral?: boolean): Promise<void>;
+    /**
+     * Emit a tool use activity (ephemeral by default)
+     */
+    emitToolUse(tool: string, input: Record<string, unknown>, ephemeral?: boolean): Promise<void>;
+    /**
+     * Emit a response activity (persisted)
+     */
+    emitResponse(content: string): Promise<void>;
+    /**
+     * Emit an error activity (persisted)
+     */
+    emitError(error: Error | string): Promise<void>;
+    /**
+     * Report a tool error as a Linear issue for tracking and improvement.
+     * Creates a bug in the Agent project backlog.
+     *
+     * @param toolName - Name of the tool that errored
+     * @param errorMessage - The error message
+     * @param context - Additional context about the error
+     * @returns The created issue, or null if creation failed or was deduplicated
+     */
+    reportToolError(toolName: string, errorMessage: string, context?: {
+        issueIdentifier?: string;
+        additionalContext?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+        identifier: string;
+        url: string;
+    } | null>;
+    /**
+     * Queue an activity for emission with rate limiting
+     */
+    private queueActivity;
+    /**
+     * Process queued activities
+     */
+    private processQueue;
+    /**
+     * Merge consecutive similar activities in the queue
+     */
+    private mergeQueuedActivities;
+    /**
+     * Emit a single activity to Linear
+     */
+    private emitActivity;
+    /**
+     * Summarize tool input for display
+     */
+    private summarizeToolInput;
+    /**
+     * Truncate long output strings
+     */
+    private truncateOutput;
+    /**
+     * Flush all pending activities immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Helper delay function
+     */
+    private delay;
+}
+/**
+ * Create an activity emitter instance
+ */
+export declare function createActivityEmitter(config: ActivityEmitterConfig): ActivityEmitter;
+//# sourceMappingURL=activity-emitter.d.ts.map

package/dist/src/orchestrator/activity-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-emitter.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/activity-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,6CAA6C;AAC7C,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,OAAO,EAAE,YAAY,CAAA;IACrB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wEAAwE;IACxE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D,sDAAsD;IACtD,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9D;AAcD;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAyC;IAC5E,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAyC;IAE9E,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,UAAU,CAA6C;IAC/D,OAAO,CAAC,YAAY,CAAQ;IAE5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAyB;gBAEhD,MAAM,EAAE,qBAAqB;IASzC;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpE;;OAEG;IACG,WAAW,CACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,UAAO,GACf,OAAO,CAAC,IAAI,CAAC;IAWhB;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlD;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASrD;;;;;;;;OAQG;IACG,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE;QACR,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAC5C,GACA,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IA2BlE;;OAEG;YACW,aAAa;IAe3B;;OAEG;YACW,YAAY;IA+B1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAiD7B;;OAEG;YACW,YAAY;IA6C1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoC1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,GAC5B,eAAe,CAEjB"}

package/dist/src/orchestrator/activity-emitter.js

@@ -0,0 +1,306 @@
+/**
+ * Linear Activity Emitter
+ *
+ * Emits Claude stream events to Linear as agent activities.
+ * Handles rate limiting by batching rapid activities and
+ * truncating long outputs.
+ *
+ * Mapping:
+ * - assistant message → response (persisted, user-directed communication)
+ * - tool_use → action (ephemeral)
+ * - tool_result → action (ephemeral)
+ * - result → response (persisted)
+ * - error → error (persisted)
+ */
+import { ENVIRONMENT_ISSUE_TYPES } from '@renseiai/agentfactory-linear';
+const DEFAULT_MIN_INTERVAL = 500;
+const DEFAULT_MAX_OUTPUT_LENGTH = 2000;
+/**
+ * Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear activities.
+ */
+export class ActivityEmitter {
+    session;
+    minInterval;
+    maxOutputLength;
+    includeTimestamps;
+    onActivityEmitted;
+    onActivityThrottled;
+    lastEmitTime = 0;
+    queue = [];
+    flushTimer = null;
+    isProcessing = false;
+    // Track reported tool error signatures for deduplication
+    reportedToolErrors = new Set();
+    constructor(config) {
+        this.session = config.session;
+        this.minInterval = config.minInterval ?? DEFAULT_MIN_INTERVAL;
+        this.maxOutputLength = config.maxOutputLength ?? DEFAULT_MAX_OUTPUT_LENGTH;
+        this.includeTimestamps = config.includeTimestamps ?? false;
+        this.onActivityEmitted = config.onActivityEmitted;
+        this.onActivityThrottled = config.onActivityThrottled;
+    }
+    /**
+     * Emit a thought activity (persistent by default for visibility in Linear)
+     */
+    async emitThought(content, ephemeral = false) {
+        await this.queueActivity({
+            type: 'thought',
+            content,
+            ephemeral,
+        });
+    }
+    /**
+     * Emit a tool use activity (ephemeral by default)
+     */
+    async emitToolUse(tool, input, ephemeral = true) {
+        const inputSummary = this.summarizeToolInput(tool, input);
+        await this.queueActivity({
+            type: 'action',
+            content: `${tool}: ${inputSummary}`,
+            ephemeral,
+            toolName: tool,
+            toolInput: input,
+        });
+    }
+    /**
+     * Emit a response activity (persisted)
+     */
+    async emitResponse(content) {
+        await this.queueActivity({
+            type: 'response',
+            content,
+            ephemeral: false,
+        });
+    }
+    /**
+     * Emit an error activity (persisted)
+     */
+    async emitError(error) {
+        const message = error instanceof Error ? error.message : error;
+        await this.queueActivity({
+            type: 'error',
+            content: message,
+            ephemeral: false,
+        });
+    }
+    /**
+     * Report a tool error as a Linear issue for tracking and improvement.
+     * Creates a bug in the Agent project backlog.
+     *
+     * @param toolName - Name of the tool that errored
+     * @param errorMessage - The error message
+     * @param context - Additional context about the error
+     * @returns The created issue, or null if creation failed or was deduplicated
+     */
+    async reportToolError(toolName, errorMessage, context) {
+        // Deduplicate using tool name + first 100 chars of error
+        const signature = `${toolName}:${errorMessage.substring(0, 100)}`;
+        if (this.reportedToolErrors.has(signature)) {
+            return null;
+        }
+        this.reportedToolErrors.add(signature);
+        try {
+            return await this.session.reportEnvironmentIssue(`Tool error: ${toolName}`, `The agent encountered an error while using the **${toolName}** tool.\n\n**Error:**\n\`\`\`\n${errorMessage}\n\`\`\``, {
+                issueType: ENVIRONMENT_ISSUE_TYPES.TOOL,
+                sourceIssueId: context?.issueIdentifier,
+                additionalContext: {
+                    toolName,
+                    ...context?.additionalContext,
+                },
+            });
+        }
+        catch (error) {
+            console.error('[ActivityEmitter] Failed to report tool error:', error);
+            return null;
+        }
+    }
+    /**
+     * Queue an activity for emission with rate limiting
+     */
+    async queueActivity(activity) {
+        this.queue.push(activity);
+        // Schedule flush if not already scheduled
+        if (!this.flushTimer && !this.isProcessing) {
+            const timeSinceLastEmit = Date.now() - this.lastEmitTime;
+            const delay = Math.max(0, this.minInterval - timeSinceLastEmit);
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.processQueue();
+            }, delay);
+        }
+    }
+    /**
+     * Process queued activities
+     */
+    async processQueue() {
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        try {
+            // Merge similar consecutive activities to reduce API calls
+            const merged = this.mergeQueuedActivities();
+            for (const activity of merged) {
+                await this.emitActivity(activity);
+                this.lastEmitTime = Date.now();
+                // Small delay between emissions to avoid rate limits
+                if (merged.length > 1) {
+                    await this.delay(100);
+                }
+            }
+        }
+        finally {
+            this.isProcessing = false;
+            // If more activities were queued during processing, schedule another flush
+            if (this.queue.length > 0 && !this.flushTimer) {
+                this.flushTimer = setTimeout(() => {
+                    this.flushTimer = null;
+                    this.processQueue();
+                }, this.minInterval);
+            }
+        }
+    }
+    /**
+     * Merge consecutive similar activities in the queue
+     */
+    mergeQueuedActivities() {
+        const activities = [...this.queue];
+        this.queue = [];
+        if (activities.length <= 1)
+            return activities;
+        const merged = [];
+        let current = activities[0];
+        for (let i = 1; i < activities.length; i++) {
+            const next = activities[i];
+            // Merge consecutive thoughts
+            if (current.type === 'thought' &&
+                next.type === 'thought' &&
+                current.ephemeral === next.ephemeral) {
+                current = {
+                    ...current,
+                    content: `${current.content}\n\n${next.content}`,
+                };
+                this.onActivityThrottled?.('thought', next.content);
+                continue;
+            }
+            // Merge consecutive tool results for same tool
+            if (current.type === 'action' &&
+                next.type === 'action' &&
+                current.toolName === next.toolName &&
+                current.ephemeral === next.ephemeral) {
+                current = {
+                    ...current,
+                    content: `${current.content}\n${next.content}`,
+                };
+                this.onActivityThrottled?.('action', next.content);
+                continue;
+            }
+            merged.push(current);
+            current = next;
+        }
+        merged.push(current);
+        return merged;
+    }
+    /**
+     * Emit a single activity to Linear
+     */
+    async emitActivity(activity) {
+        try {
+            const content = this.includeTimestamps
+                ? `[${new Date().toISOString()}] ${activity.content}`
+                : activity.content;
+            switch (activity.type) {
+                case 'thought':
+                    await this.session.emitThought(content, activity.ephemeral);
+                    break;
+                case 'action':
+                    if (activity.toolName && activity.toolInput) {
+                        await this.session.emitAction(activity.toolName, activity.toolInput, activity.ephemeral);
+                    }
+                    else if (activity.toolName && activity.toolOutput) {
+                        await this.session.emitToolResult(activity.toolName, activity.toolOutput, activity.ephemeral);
+                    }
+                    else {
+                        // Generic action - emit as thought
+                        await this.session.emitThought(content, activity.ephemeral);
+                    }
+                    break;
+                case 'response':
+                    await this.session.emitResponse(content);
+                    break;
+                case 'error':
+                    await this.session.emitError(new Error(content));
+                    break;
+            }
+            this.onActivityEmitted?.(activity.type, content);
+        }
+        catch (error) {
+            console.error(`Failed to emit ${activity.type} activity:`, error);
+        }
+    }
+    /**
+     * Summarize tool input for display
+     */
+    summarizeToolInput(tool, input) {
+        // Tool-specific summaries
+        switch (tool) {
+            case 'Read':
+                return String(input.file_path || input.path || 'file');
+            case 'Write':
+                return String(input.file_path || input.path || 'file');
+            case 'Edit':
+                return String(input.file_path || input.path || 'file');
+            case 'Grep':
+                return `"${input.pattern}" in ${input.path || '.'}`;
+            case 'Glob':
+                return String(input.pattern || '*');
+            case 'Bash':
+                const cmd = String(input.command || '');
+                return cmd.length > 50 ? cmd.substring(0, 47) + '...' : cmd;
+            case 'Task':
+                return String(input.description || input.prompt || 'task');
+            default:
+                // Generic: show first string value or truncated JSON
+                const firstStringValue = Object.values(input).find((v) => typeof v === 'string');
+                if (firstStringValue) {
+                    return firstStringValue.length > 50
+                        ? firstStringValue.substring(0, 47) + '...'
+                        : firstStringValue;
+                }
+                const json = JSON.stringify(input);
+                return json.length > 50 ? json.substring(0, 47) + '...' : json;
+        }
+    }
+    /**
+     * Truncate long output strings
+     */
+    truncateOutput(output) {
+        if (output.length <= this.maxOutputLength)
+            return output;
+        return (output.substring(0, this.maxOutputLength) +
+            `\n\n... (truncated ${output.length - this.maxOutputLength} chars)`);
+    }
+    /**
+     * Flush all pending activities immediately
+     */
+    async flush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.processQueue();
+    }
+    /**
+     * Helper delay function
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Create an activity emitter instance
+ */
+export function createActivityEmitter(config) {
+    return new ActivityEmitter(config);
+}