@syntesseraai/opencode-feature-factory 0.2.2 → 0.2.4

package/dist/discovery.d.ts

@@ -0,0 +1,18 @@
+import type { CommandStep, QualityGateConfig } from './types';
+type BunShell = any;
+/**
+ * Resolve the command plan based on configuration and discovery.
+ *
+ * Resolution order:
+ * 1. Configured commands (qualityGate.lint/build/test) - highest priority
+ * 2. management/ci.sh (Feature Factory convention) - only if no configured commands
+ * 3. Conventional discovery (Node/Rust/Go/Python) - only if no ci.sh
+ *
+ * @returns Array of command steps to execute, or empty if nothing found
+ */
+export declare function resolveCommands(args: {
+    $: BunShell;
+    directory: string;
+    config: QualityGateConfig;
+}): Promise<CommandStep[]>;
+export {};

package/dist/discovery.js

@@ -0,0 +1,189 @@
+import { DEFAULT_QUALITY_GATE, fileExists, hasConfiguredCommands, readJsonFile, } from './quality-gate-config';
+// ============================================================================
+// Package Manager Detection
+// ============================================================================
+/**
+ * Detect the package manager based on lockfile presence.
+ * Priority: pnpm > bun > yarn > npm
+ */
+async function detectPackageManager($, directory, override) {
+    if (override && override !== 'auto') {
+        return override;
+    }
+    // Priority order: pnpm > bun > yarn > npm
+    if (await fileExists($, `${directory}/pnpm-lock.yaml`))
+        return 'pnpm';
+    if (await fileExists($, `${directory}/bun.lockb`))
+        return 'bun';
+    if (await fileExists($, `${directory}/bun.lock`))
+        return 'bun';
+    if (await fileExists($, `${directory}/yarn.lock`))
+        return 'yarn';
+    if (await fileExists($, `${directory}/package-lock.json`))
+        return 'npm';
+    return 'npm'; // fallback
+}
+/**
+ * Build the run command for a given package manager and script name
+ */
+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}`;
+    }
+}
+// ============================================================================
+// Node.js Discovery
+// ============================================================================
+/**
+ * Discover Node.js lint/build/test commands from package.json scripts
+ */
+async function discoverNodeCommands($, directory, pm) {
+    const pkgJson = await readJsonFile($, `${directory}/package.json`);
+    if (!pkgJson?.scripts)
+        return [];
+    const scripts = pkgJson.scripts;
+    const steps = [];
+    // Lint: prefer lint:ci, then lint
+    const lintScript = scripts['lint:ci'] ? 'lint:ci' : scripts['lint'] ? 'lint' : null;
+    if (lintScript) {
+        steps.push({ step: 'lint', cmd: buildRunCommand(pm, lintScript) });
+    }
+    // Build: prefer build:ci, then build
+    const buildScript = scripts['build:ci'] ? 'build:ci' : scripts['build'] ? 'build' : null;
+    if (buildScript) {
+        steps.push({ step: 'build', cmd: buildRunCommand(pm, buildScript) });
+    }
+    // Test: prefer test:ci, then test
+    const testScript = scripts['test:ci'] ? 'test:ci' : scripts['test'] ? 'test' : null;
+    if (testScript) {
+        steps.push({ step: 'test', cmd: buildRunCommand(pm, testScript) });
+    }
+    return steps;
+}
+// ============================================================================
+// Rust Discovery
+// ============================================================================
+/**
+ * Discover Rust commands from Cargo.toml presence
+ */
+async function discoverRustCommands($, directory, includeClippy) {
+    if (!(await fileExists($, `${directory}/Cargo.toml`)))
+        return [];
+    const steps = [{ step: 'lint (fmt)', cmd: 'cargo fmt --check' }];
+    if (includeClippy) {
+        steps.push({
+            step: 'lint (clippy)',
+            cmd: 'cargo clippy --all-targets --all-features',
+        });
+    }
+    steps.push({ step: 'build', cmd: 'cargo build' });
+    steps.push({ step: 'test', cmd: 'cargo test' });
+    return steps;
+}
+// ============================================================================
+// Go Discovery
+// ============================================================================
+/**
+ * Discover Go commands from go.mod presence
+ */
+async function discoverGoCommands($, directory) {
+    if (!(await fileExists($, `${directory}/go.mod`)))
+        return [];
+    return [{ step: 'test', cmd: 'go test ./...' }];
+}
+// ============================================================================
+// Python Discovery
+// ============================================================================
+/**
+ * Discover Python test commands with strong signal detection
+ */
+async function discoverPythonCommands($, directory) {
+    // Only add pytest if we have strong signal
+    const hasPytestIni = await fileExists($, `${directory}/pytest.ini`);
+    const hasPyproject = await fileExists($, `${directory}/pyproject.toml`);
+    if (!hasPytestIni && !hasPyproject)
+        return [];
+    // pytest.ini is strong signal
+    if (hasPytestIni) {
+        return [{ step: 'test', cmd: 'pytest' }];
+    }
+    // Check if pyproject.toml mentions pytest
+    if (hasPyproject) {
+        try {
+            const result = await $ `cat ${directory}/pyproject.toml`.quiet();
+            const content = result.text();
+            if (content.includes('pytest')) {
+                return [{ step: 'test', cmd: 'pytest' }];
+            }
+        }
+        catch {
+            // Ignore read errors - return empty array if file can't be read
+        }
+    }
+    return [];
+}
+// ============================================================================
+// Main Resolution Logic
+// ============================================================================
+/**
+ * Resolve the command plan based on configuration and discovery.
+ *
+ * Resolution order:
+ * 1. Configured commands (qualityGate.lint/build/test) - highest priority
+ * 2. management/ci.sh (Feature Factory convention) - only if no configured commands
+ * 3. Conventional discovery (Node/Rust/Go/Python) - only if no ci.sh
+ *
+ * @returns Array of command steps to execute, or empty if nothing found
+ */
+export async function resolveCommands(args) {
+    const { $, directory, config } = args;
+    const mergedConfig = { ...DEFAULT_QUALITY_GATE, ...config };
+    // 1. Configured commands take priority (do NOT run ci.sh if these exist)
+    if (hasConfiguredCommands(config)) {
+        const steps = [];
+        const order = mergedConfig.steps;
+        for (const stepName of order) {
+            const cmd = config[stepName];
+            if (cmd) {
+                steps.push({ step: stepName, cmd });
+            }
+        }
+        return steps;
+    }
+    // 2. Feature Factory CI script (only if no configured commands)
+    if (mergedConfig.useCiSh !== 'never') {
+        const ciShPath = `${directory}/management/ci.sh`;
+        if (await fileExists($, ciShPath)) {
+            return [{ step: 'ci', cmd: `bash ${ciShPath}` }];
+        }
+    }
+    // 3. Conventional discovery (only if no ci.sh)
+    const pm = await detectPackageManager($, directory, mergedConfig.packageManager);
+    // Try Node first (most common)
+    if (await fileExists($, `${directory}/package.json`)) {
+        const nodeSteps = await discoverNodeCommands($, directory, pm);
+        if (nodeSteps.length > 0)
+            return nodeSteps;
+    }
+    // Rust
+    const rustSteps = await discoverRustCommands($, directory, mergedConfig.include?.rustClippy ?? true);
+    if (rustSteps.length > 0)
+        return rustSteps;
+    // Go
+    const goSteps = await discoverGoCommands($, directory);
+    if (goSteps.length > 0)
+        return goSteps;
+    // Python
+    const pythonSteps = await discoverPythonCommands($, directory);
+    if (pythonSteps.length > 0)
+        return pythonSteps;
+    // No commands discovered
+    return [];
+}

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,95 @@
+/**
+ * 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}`;
+    }
+}
+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/index.d.ts

@@ -0,0 +1,30 @@
+import type { Plugin } from '@opencode-ai/plugin';
+export declare const SKILL_PATHS: {
+    'ff-mini-plan': string;
+    'ff-todo-management': string;
+    'ff-severity-classification': string;
+    'ff-report-templates': string;
+};
+export declare const AGENT_PATHS: {
+    'ff-acceptance': string;
+    'ff-review': string;
+    'ff-security': string;
+    'ff-well-architected': string;
+    'ff-validate': string;
+};
+/**
+ * Stop Quality Gate Plugin
+ *
+ * Runs quality gate checks when the agent becomes idle after editing files.
+ *
+ * Behavior:
+ * - Runs quality gate on session.idle (when agent finishes working)
+ * - Executes management/ci.sh directly (no LLM involvement)
+ * - On fast feedback: "Quality gate is running, please stand-by for results ..."
+ * - On success: "Quality gate passed"
+ * - On failure: passes full CI output to LLM for fix instructions
+ * - If management/ci.sh does not exist, quality gate does not run
+ */
+export declare const StopQualityGatePlugin: Plugin;
+export default StopQualityGatePlugin;
+export type { QualityGateConfig, CommandStep, StepResult, SessionState, PackageManager, } from './types';

package/dist/index.js

@@ -0,0 +1,81 @@
+import { createQualityGateHooks } from './stop-quality-gate';
+// Export skill and agent paths for programmatic access
+export const SKILL_PATHS = {
+    'ff-mini-plan': './skills/ff-mini-plan/SKILL.md',
+    'ff-todo-management': './skills/ff-todo-management/SKILL.md',
+    'ff-severity-classification': './skills/ff-severity-classification/SKILL.md',
+    'ff-report-templates': './skills/ff-report-templates/SKILL.md',
+};
+export const AGENT_PATHS = {
+    'ff-acceptance': './agents/ff-acceptance.md',
+    'ff-review': './agents/ff-review.md',
+    'ff-security': './agents/ff-security.md',
+    'ff-well-architected': './agents/ff-well-architected.md',
+    'ff-validate': './agents/ff-validate.md',
+};
+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
+    }
+}
+/**
+ * Determine the project root directory.
+ * Prefer worktree (git root) if available, otherwise use directory.
+ */
+function resolveRootDir(input) {
+    const worktree = (input.worktree ?? '').trim();
+    if (worktree.length > 0)
+        return worktree;
+    return input.directory;
+}
+/**
+ * Stop Quality Gate Plugin
+ *
+ * Runs quality gate checks when the agent becomes idle after editing files.
+ *
+ * Behavior:
+ * - Runs quality gate on session.idle (when agent finishes working)
+ * - Executes management/ci.sh directly (no LLM involvement)
+ * - On fast feedback: "Quality gate is running, please stand-by for results ..."
+ * - On success: "Quality gate passed"
+ * - On failure: passes full CI output to LLM for fix instructions
+ * - If management/ci.sh does not exist, quality gate does not run
+ */
+export const StopQualityGatePlugin = async (input) => {
+    const { worktree, directory, client } = input;
+    const rootDir = resolveRootDir({ worktree, directory });
+    // Skip quality gate if no valid directory (e.g., global config with no project)
+    if (!rootDir || rootDir === '' || rootDir === '/') {
+        return {};
+    }
+    // Create quality gate hooks
+    let qualityGateHooks = {};
+    try {
+        qualityGateHooks = await createQualityGateHooks(input);
+    }
+    catch (error) {
+        await log(client, 'error', 'quality-gate.init-error', {
+            error: String(error),
+        });
+    }
+    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 {};