@syntesseraai/opencode-feature-factory 0.2.21 → 0.2.23

package/dist/discovery.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Unit tests for discovery module
+ *
+ * Tests focus on the pure function:
+ * - buildRunCommand: builds package manager-specific run commands
+ *
+ * Note: Most functions in discovery.ts require shell access ($) so they're
+ * integration-tested elsewhere. This file tests the pure utility functions.
+ */
+export {};

package/dist/discovery.test.js

@@ -0,0 +1,97 @@
+/**
+ * Unit tests for discovery module
+ *
+ * Tests focus on the pure function:
+ * - buildRunCommand: builds package manager-specific run commands
+ *
+ * Note: Most functions in discovery.ts require shell access ($) so they're
+ * integration-tested elsewhere. This file tests the pure utility functions.
+ */
+// Re-implement buildRunCommand for testing since it's not exported
+function buildRunCommand(pm, script) {
+    switch (pm) {
+        case 'pnpm':
+            return `pnpm -s run ${script}`;
+        case 'bun':
+            return `bun run ${script}`;
+        case 'yarn':
+            return `yarn -s ${script}`;
+        case 'npm':
+            return `npm run -s ${script}`;
+        default:
+            return `npm run -s ${script}`;
+    }
+}
+describe('buildRunCommand', () => {
+    describe('pnpm', () => {
+        it('should build correct pnpm command', () => {
+            expect(buildRunCommand('pnpm', 'lint')).toBe('pnpm -s run lint');
+        });
+        it('should build correct pnpm command for build script', () => {
+            expect(buildRunCommand('pnpm', 'build')).toBe('pnpm -s run build');
+        });
+        it('should build correct pnpm command for test script', () => {
+            expect(buildRunCommand('pnpm', 'test')).toBe('pnpm -s run test');
+        });
+        it('should handle scripts with colons', () => {
+            expect(buildRunCommand('pnpm', 'lint:ci')).toBe('pnpm -s run lint:ci');
+        });
+    });
+    describe('bun', () => {
+        it('should build correct bun command', () => {
+            expect(buildRunCommand('bun', 'lint')).toBe('bun run lint');
+        });
+        it('should build correct bun command for build script', () => {
+            expect(buildRunCommand('bun', 'build')).toBe('bun run build');
+        });
+        it('should build correct bun command for test script', () => {
+            expect(buildRunCommand('bun', 'test')).toBe('bun run test');
+        });
+    });
+    describe('yarn', () => {
+        it('should build correct yarn command', () => {
+            expect(buildRunCommand('yarn', 'lint')).toBe('yarn -s lint');
+        });
+        it('should build correct yarn command for build script', () => {
+            expect(buildRunCommand('yarn', 'build')).toBe('yarn -s build');
+        });
+        it('should build correct yarn command for test script', () => {
+            expect(buildRunCommand('yarn', 'test')).toBe('yarn -s test');
+        });
+    });
+    describe('npm', () => {
+        it('should build correct npm command', () => {
+            expect(buildRunCommand('npm', 'lint')).toBe('npm run -s lint');
+        });
+        it('should build correct npm command for build script', () => {
+            expect(buildRunCommand('npm', 'build')).toBe('npm run -s build');
+        });
+        it('should build correct npm command for test script', () => {
+            expect(buildRunCommand('npm', 'test')).toBe('npm run -s test');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle script names with hyphens', () => {
+            expect(buildRunCommand('npm', 'type-check')).toBe('npm run -s type-check');
+        });
+        it('should handle script names with underscores', () => {
+            expect(buildRunCommand('pnpm', 'lint_fix')).toBe('pnpm -s run lint_fix');
+        });
+        it('should handle long script names', () => {
+            expect(buildRunCommand('yarn', 'test:unit:coverage')).toBe('yarn -s test:unit:coverage');
+        });
+    });
+});
+/**
+ * PackageManager type validation tests
+ * These ensure the type constraints are working correctly
+ */
+describe('PackageManager type', () => {
+    it('should accept valid package manager values', () => {
+        const validManagers = ['pnpm', 'bun', 'yarn', 'npm'];
+        validManagers.forEach((pm) => {
+            expect(['pnpm', 'bun', 'yarn', 'npm']).toContain(pm);
+        });
+    });
+});
+export {};

package/dist/feature-factory-setup.d.ts

@@ -0,0 +1,9 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+type BunShell = any;
+/**
+ * Initialize the Feature Factory directory structure.
+ * Creates .feature-factory/ and .feature-factory/agents/ directories.
+ * Migrates management/ci.sh to .feature-factory/ci.sh if it exists.
+ */
+export declare function initializeFeatureFactory(input: PluginInput, $: BunShell): Promise<void>;
+export {};

package/dist/feature-factory-setup.js

@@ -0,0 +1,151 @@
+const SERVICE_NAME = 'feature-factory';
+/**
+ * Log a message using the OpenCode client's structured logging.
+ * Silently fails if logging is unavailable.
+ */
+async function log(client, level, message, extra) {
+    try {
+        await client.app.log({
+            body: {
+                service: SERVICE_NAME,
+                level,
+                message,
+                extra,
+            },
+        });
+    }
+    catch {
+        // Logging failure should not affect plugin operation
+    }
+}
+/**
+ * Execute a shell command with a timeout to prevent hangs
+ */
+async function executeWithTimeout(operation, timeoutMs = 5000, operationName = 'shell command') {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`${operationName} timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation(), timeoutPromise]);
+    }
+    catch (error) {
+        // Return null on timeout or error
+        return null;
+    }
+}
+/**
+ * Validate that a directory path is safe to use
+ */
+function isValidDirectory(directory) {
+    if (!directory || typeof directory !== 'string')
+        return false;
+    if (directory === '' || directory === '/')
+        return false;
+    // Check for common invalid patterns
+    if (directory.includes('\0') || directory.includes('..'))
+        return false;
+    return true;
+}
+/**
+ * Initialize the Feature Factory directory structure.
+ * Creates .feature-factory/ and .feature-factory/agents/ directories.
+ * Migrates management/ci.sh to .feature-factory/ci.sh if it exists.
+ */
+export async function initializeFeatureFactory(input, $) {
+    const { directory, client } = input;
+    // Validate directory before attempting any operations
+    if (!isValidDirectory(directory)) {
+        await log(client, 'debug', 'feature-factory-init-skipped-invalid-directory', {
+            directory: String(directory),
+        });
+        return;
+    }
+    const featureFactoryDir = `${directory}/.feature-factory`;
+    const agentsDir = `${featureFactoryDir}/agents`;
+    // Create directories if they don't exist (with timeout protection)
+    try {
+        const result = await executeWithTimeout(async () => await $ `mkdir -p ${agentsDir}`.quiet(), 3000, 'mkdir -p');
+        if (result === null) {
+            await log(client, 'warn', 'feature-factory-directory-creation-timeout', {
+                agentsDir,
+            });
+            return; // Exit early if we can't create directories
+        }
+        await log(client, 'debug', 'feature-factory-directories-created', {
+            featureFactoryDir,
+            agentsDir,
+        });
+    }
+    catch (error) {
+        await log(client, 'warn', 'feature-factory-directory-creation-failed', {
+            error: String(error),
+        });
+        // Continue even if directory creation fails - it might already exist
+    }
+    // Check for CI script migration (with timeout protection)
+    const oldCiPath = `${directory}/management/ci.sh`;
+    const newCiPath = `${featureFactoryDir}/ci.sh`;
+    try {
+        // Check if old CI exists (with timeout)
+        const oldExists = await executeWithTimeout(async () => {
+            await $ `test -f ${oldCiPath}`.quiet();
+            return true;
+        }, 2000, 'test -f old-ci');
+        if (oldExists !== true) {
+            // Old doesn't exist, nothing to migrate
+            await log(client, 'debug', 'ci-sh-no-migration-needed', {
+                oldPath: oldCiPath,
+            });
+            return;
+        }
+        // Old exists, check if new already exists (with timeout)
+        const newExists = await executeWithTimeout(async () => {
+            await $ `test -f ${newCiPath}`.quiet();
+            return true;
+        }, 2000, 'test -f new-ci');
+        if (newExists === true) {
+            // Both exist - migration already done or user has both
+            await log(client, 'debug', 'ci-sh-both-locations-exist', {
+                oldPath: oldCiPath,
+                newPath: newCiPath,
+            });
+            return;
+        }
+        // Old exists, new doesn't - migrate (with timeout)
+        const copied = await executeWithTimeout(async () => {
+            await $ `cp ${oldCiPath} ${newCiPath}`.quiet();
+            return true;
+        }, 3000, 'cp ci.sh');
+        if (copied === true) {
+            const removed = await executeWithTimeout(async () => {
+                await $ `rm ${oldCiPath}`.quiet();
+                return true;
+            }, 2000, 'rm old-ci');
+            if (removed === true) {
+                await log(client, 'info', 'ci-sh-migrated', {
+                    from: oldCiPath,
+                    to: newCiPath,
+                });
+            }
+            else {
+                await log(client, 'warn', 'ci-sh-migration-partial', {
+                    from: oldCiPath,
+                    to: newCiPath,
+                    reason: 'copied but failed to remove old file',
+                });
+            }
+        }
+        else {
+            await log(client, 'error', 'ci-sh-migration-failed', {
+                from: oldCiPath,
+                to: newCiPath,
+                reason: 'copy operation timed out or failed',
+            });
+        }
+    }
+    catch (error) {
+        await log(client, 'error', 'ci-sh-migration-error', {
+            error: String(error),
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from '@opencode-ai/plugin';
+/**
+ * Stop Quality Gate Plugin
+ *
+ * Runs quality gate checks when the agent becomes idle after editing files.
+ */
+export declare const StopQualityGatePlugin: Plugin;
+export default StopQualityGatePlugin;
+export type { QualityGateConfig, CommandStep, StepResult, SessionState, PackageManager, } from './types.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+import { StopQualityGateHooksPlugin } from './stop-quality-gate.js';
+/**
+ * Stop Quality Gate Plugin
+ *
+ * Runs quality gate checks when the agent becomes idle after editing files.
+ */
+export const StopQualityGatePlugin = async (input) => {
+    const { directory } = input;
+    // Skip if no valid directory
+    if (!directory || directory === '' || directory === '/') {
+        return {};
+    }
+    // Load quality gate plugin only (agents disabled for testing)
+    const qualityGateHooks = await StopQualityGateHooksPlugin(input).catch(() => ({}));
+    return qualityGateHooks;
+};
+// Default export for OpenCode plugin discovery
+export default StopQualityGatePlugin;

package/dist/output.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Extract lines that likely contain error information from command output.
+ * Includes 1-2 lines of context after each error line.
+ *
+ * @param output - The command output to search
+ * @param maxLines - Maximum number of error lines to extract
+ * @returns Array of error-like lines (up to maxLines)
+ */
+export declare function extractErrorLines(output: string, maxLines: number): string[];
+/**
+ * Return the last N lines of output, with a truncation notice if needed.
+ *
+ * @param output - The full command output
+ * @param maxLines - Maximum number of lines to return
+ * @returns Truncated output with notice, or full output if short enough
+ */
+export declare function tailLines(output: string, maxLines: number): string;

package/dist/output.js

@@ -0,0 +1,48 @@
+/**
+ * Regex pattern for detecting error-like lines in command output
+ */
+const ERROR_PATTERNS = /(error|failed|failure|panic|assert|exception|traceback|TypeError|ReferenceError|SyntaxError|FAILED|FAIL|ERR!)/i;
+/**
+ * Extract lines that likely contain error information from command output.
+ * Includes 1-2 lines of context after each error line.
+ *
+ * @param output - The command output to search
+ * @param maxLines - Maximum number of error lines to extract
+ * @returns Array of error-like lines (up to maxLines)
+ */
+export function extractErrorLines(output, maxLines) {
+    const lines = output.split('\n');
+    const errorLines = [];
+    for (let i = 0; i < lines.length && errorLines.length < maxLines; i++) {
+        const line = lines[i];
+        if (line && ERROR_PATTERNS.test(line)) {
+            errorLines.push(line);
+            // Include 1-2 lines of context after the error
+            const nextLine = lines[i + 1];
+            const nextNextLine = lines[i + 2];
+            if (nextLine !== undefined) {
+                errorLines.push(nextLine);
+            }
+            if (nextNextLine !== undefined) {
+                errorLines.push(nextNextLine);
+            }
+        }
+    }
+    return errorLines.slice(0, maxLines);
+}
+/**
+ * Return the last N lines of output, with a truncation notice if needed.
+ *
+ * @param output - The full command output
+ * @param maxLines - Maximum number of lines to return
+ * @returns Truncated output with notice, or full output if short enough
+ */
+export function tailLines(output, maxLines) {
+    const lines = output.split('\n');
+    if (lines.length <= maxLines) {
+        return output;
+    }
+    const truncatedCount = lines.length - maxLines;
+    const tail = lines.slice(-maxLines).join('\n');
+    return `... (${truncatedCount} lines truncated)\n${tail}`;
+}

package/dist/output.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Unit tests for output module
+ *
+ * Tests focus on pure functions:
+ * - extractErrorLines: extracts error-like lines from command output
+ * - tailLines: returns last N lines with truncation notice
+ */
+export {};

package/dist/output.test.js

@@ -0,0 +1,205 @@
+/**
+ * Unit tests for output module
+ *
+ * Tests focus on pure functions:
+ * - extractErrorLines: extracts error-like lines from command output
+ * - tailLines: returns last N lines with truncation notice
+ */
+import { extractErrorLines, tailLines } from './output.js';
+describe('extractErrorLines', () => {
+    it('should return empty array for empty input', () => {
+        expect(extractErrorLines('', 10)).toEqual([]);
+    });
+    it('should return empty array when no errors found', () => {
+        const output = `
+Build started
+Compiling modules...
+Build completed successfully
+`;
+        expect(extractErrorLines(output, 10)).toEqual([]);
+    });
+    it('should extract lines containing "error"', () => {
+        const output = `
+Starting build
+error: Cannot find module 'missing'
+Build failed
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('error:'))).toBe(true);
+    });
+    it('should extract lines containing "Error" (case insensitive)', () => {
+        const output = `
+Running tests
+TypeError: undefined is not a function
+  at test.js:10:5
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('TypeError'))).toBe(true);
+    });
+    it('should extract lines containing "failed"', () => {
+        const output = `
+Test suite: MyTests
+Test failed: should work correctly
+1 test failed
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.toLowerCase().includes('failed'))).toBe(true);
+    });
+    it('should extract lines containing "FAILED"', () => {
+        const output = `
+Running: test_function
+FAILED test_function - assertion error
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('FAILED'))).toBe(true);
+    });
+    it('should extract lines containing "panic"', () => {
+        const output = `
+thread 'main' panicked at 'assertion failed'
+note: run with RUST_BACKTRACE=1
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('panic'))).toBe(true);
+    });
+    it('should extract lines containing "exception"', () => {
+        const output = `
+Exception in thread "main" java.lang.NullPointerException
+  at Main.main(Main.java:5)
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('Exception'))).toBe(true);
+    });
+    it('should extract lines containing "traceback"', () => {
+        const output = `
+Traceback (most recent call last):
+  File "test.py", line 10
+NameError: name 'x' is not defined
+`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('Traceback'))).toBe(true);
+    });
+    it('should include 2 lines of context after error', () => {
+        const output = `line1
+error: something went wrong
+context line 1
+context line 2
+line5`;
+        const result = extractErrorLines(output, 10);
+        expect(result).toContain('error: something went wrong');
+        expect(result).toContain('context line 1');
+        expect(result).toContain('context line 2');
+    });
+    it('should respect maxLines limit', () => {
+        const output = `
+error: first error
+context1
+context2
+error: second error
+context3
+context4
+error: third error
+context5
+context6
+`;
+        const result = extractErrorLines(output, 5);
+        expect(result.length).toBeLessThanOrEqual(5);
+    });
+    it('should handle error at end of output without enough context lines', () => {
+        const output = `line1
+line2
+error: final error`;
+        const result = extractErrorLines(output, 10);
+        expect(result).toContain('error: final error');
+    });
+    it('should extract ReferenceError', () => {
+        const output = `ReferenceError: x is not defined`;
+        const result = extractErrorLines(output, 10);
+        expect(result).toContain('ReferenceError: x is not defined');
+    });
+    it('should extract SyntaxError', () => {
+        const output = `SyntaxError: Unexpected token '}'`;
+        const result = extractErrorLines(output, 10);
+        expect(result).toContain("SyntaxError: Unexpected token '}'");
+    });
+    it('should extract ERR! (npm style errors)', () => {
+        const output = `npm ERR! code ENOENT
+npm ERR! path /app/package.json`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('ERR!'))).toBe(true);
+    });
+    it('should extract FAIL (test runner style)', () => {
+        const output = `FAIL src/test.ts
+  Test suite failed to run`;
+        const result = extractErrorLines(output, 10);
+        expect(result.some((line) => line.includes('FAIL'))).toBe(true);
+    });
+    it('should extract multiple error types in same output', () => {
+        const output = `
+Starting build...
+error: Build failed
+TypeError: Cannot read property 'x'
+FAILED: test_something
+Build process ended
+`;
+        const result = extractErrorLines(output, 20);
+        expect(result.some((line) => line.includes('error:'))).toBe(true);
+        expect(result.some((line) => line.includes('TypeError'))).toBe(true);
+        expect(result.some((line) => line.includes('FAILED'))).toBe(true);
+    });
+});
+describe('tailLines', () => {
+    it('should return full output when lines count is less than maxLines', () => {
+        const output = 'line1\nline2\nline3';
+        expect(tailLines(output, 10)).toBe(output);
+    });
+    it('should return full output when lines count equals maxLines', () => {
+        const output = 'line1\nline2\nline3';
+        expect(tailLines(output, 3)).toBe(output);
+    });
+    it('should truncate and add notice when output exceeds maxLines', () => {
+        const output = 'line1\nline2\nline3\nline4\nline5';
+        const result = tailLines(output, 3);
+        expect(result).toContain('... (2 lines truncated)');
+        expect(result).toContain('line3');
+        expect(result).toContain('line4');
+        expect(result).toContain('line5');
+        expect(result).not.toContain('line1');
+        expect(result).not.toContain('line2');
+    });
+    it('should handle single line output', () => {
+        const output = 'single line';
+        expect(tailLines(output, 5)).toBe('single line');
+    });
+    it('should handle empty output', () => {
+        expect(tailLines('', 5)).toBe('');
+    });
+    it('should handle maxLines of 1', () => {
+        const output = 'line1\nline2\nline3';
+        const result = tailLines(output, 1);
+        expect(result).toContain('... (2 lines truncated)');
+        expect(result).toContain('line3');
+    });
+    it('should correctly count truncated lines', () => {
+        const lines = Array.from({ length: 100 }, (_, i) => `line${i + 1}`);
+        const output = lines.join('\n');
+        const result = tailLines(output, 10);
+        expect(result).toContain('... (90 lines truncated)');
+    });
+    it('should preserve line content in tail', () => {
+        const output = 'first\nsecond\nthird\nfourth\nfifth';
+        const result = tailLines(output, 2);
+        const resultLines = result.split('\n');
+        expect(resultLines[resultLines.length - 1]).toBe('fifth');
+        expect(resultLines[resultLines.length - 2]).toBe('fourth');
+    });
+    it('should handle output with empty lines', () => {
+        const output = 'line1\n\nline3\n\nline5';
+        const result = tailLines(output, 3);
+        expect(result).toContain('... (2 lines truncated)');
+    });
+    it('should handle output with only newlines', () => {
+        const output = '\n\n\n\n';
+        const result = tailLines(output, 2);
+        expect(result).toContain('... (3 lines truncated)');
+    });
+});

package/dist/plugins/ff-agents-clear-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '@opencode-ai/plugin';
+export declare const FFAgentsClearPlugin: Plugin;

package/dist/plugins/ff-agents-clear-plugin.js

@@ -0,0 +1,55 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { findAgentFiles, findAgentFilesById, findAllAgentFiles } from '../agent-context.js';
+export const FFAgentsClearPlugin = async (input) => {
+    const { $ } = input;
+    return {
+        tool: {
+            'ff-agents-clear': tool({
+                description: 'Clear agent context files. Can clear all, or filter by session, agent type, or specific UUID',
+                args: {
+                    sessionID: tool.schema
+                        .string()
+                        .optional()
+                        .describe('Clear only agents for specific session'),
+                    agent: tool.schema.string().optional().describe('Clear only specific agent type'),
+                    id: tool.schema.string().optional().describe('Clear specific agent by UUID'),
+                },
+                async execute(args) {
+                    try {
+                        let files = [];
+                        if (args.id) {
+                            files = await findAgentFilesById(input, args.id);
+                        }
+                        else if (args.agent && args.sessionID) {
+                            files = await findAgentFiles(input, args.agent, args.sessionID);
+                        }
+                        else if (args.sessionID) {
+                            files = await findAgentFiles(input, undefined, args.sessionID);
+                        }
+                        else if (args.agent) {
+                            files = await findAgentFiles(input, args.agent);
+                        }
+                        else {
+                            files = await findAllAgentFiles(input);
+                        }
+                        if (files.length === 0) {
+                            return 'No agent context files found to clear.';
+                        }
+                        for (const file of files) {
+                            try {
+                                await $ `rm ${file}`.quiet();
+                            }
+                            catch {
+                                // Continue even if one file fails
+                            }
+                        }
+                        return `Cleared ${files.length} agent context file(s)`;
+                    }
+                    catch (error) {
+                        return `Error clearing agents: ${error}`;
+                    }
+                },
+            }),
+        },
+    };
+};

package/dist/plugins/ff-agents-current-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '@opencode-ai/plugin';
+export declare const FFAgentsCurrentPlugin: Plugin;