@syntesseraai/opencode-feature-factory 0.2.3 → 0.2.4

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';
+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/quality-gate-config.d.ts

@@ -0,0 +1,37 @@
+import type { QualityGateConfig } from './types';
+/**
+ * Default configuration values for StopQualityGate
+ */
+export declare const DEFAULT_QUALITY_GATE: Required<Omit<QualityGateConfig, 'lint' | 'build' | 'test' | 'cwd'>>;
+type BunShell = any;
+/**
+ * Read a JSON file safely, returning null if not found or invalid
+ */
+export declare function readJsonFile($: BunShell, path: string): Promise<Record<string, unknown> | null>;
+/**
+ * Check if a file exists
+ */
+export declare function fileExists($: BunShell, path: string): Promise<boolean>;
+/**
+ * Merge two qualityGate config objects.
+ *
+ * Precedence: `.opencode/opencode.json` overrides `opencode.json` (root).
+ * Deep-merges nested objects like `include`.
+ */
+export declare function mergeQualityGateConfig(root: QualityGateConfig | undefined, dotOpencode: QualityGateConfig | undefined): QualityGateConfig;
+/**
+ * Load and merge qualityGate config from both config file locations.
+ *
+ * Reads from:
+ * - `${directory}/opencode.json`
+ * - `${directory}/.opencode/opencode.json`
+ *
+ * Merges ONLY the `qualityGate` key. `.opencode/opencode.json` takes precedence.
+ */
+export declare function loadQualityGateConfig($: BunShell, directory: string): Promise<QualityGateConfig>;
+/**
+ * Check if any explicit commands are configured (lint/build/test).
+ * If so, these take priority over ci.sh and discovery.
+ */
+export declare function hasConfiguredCommands(config: QualityGateConfig): boolean;
+export {};

package/dist/quality-gate-config.js

@@ -0,0 +1,84 @@
+/**
+ * Default configuration values for StopQualityGate
+ */
+export const DEFAULT_QUALITY_GATE = {
+    steps: ['lint', 'build', 'test'],
+    useCiSh: 'auto',
+    packageManager: 'auto',
+    cacheSeconds: 30,
+    maxOutputLines: 160,
+    maxErrorLines: 60,
+    include: {
+        rustClippy: true,
+    },
+};
+/**
+ * Read a JSON file safely, returning null if not found or invalid
+ */
+export async function readJsonFile($, path) {
+    try {
+        const result = await $ `cat ${path}`.quiet();
+        return JSON.parse(result.text());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a file exists
+ */
+export async function fileExists($, path) {
+    try {
+        await $ `test -f ${path}`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Merge two qualityGate config objects.
+ *
+ * Precedence: `.opencode/opencode.json` overrides `opencode.json` (root).
+ * Deep-merges nested objects like `include`.
+ */
+export function mergeQualityGateConfig(root, dotOpencode) {
+    const base = root ?? {};
+    const override = dotOpencode ?? {};
+    return {
+        ...base,
+        ...override,
+        // Deep merge the `include` object
+        include: {
+            ...(base.include ?? {}),
+            ...(override.include ?? {}),
+        },
+    };
+}
+/**
+ * Load and merge qualityGate config from both config file locations.
+ *
+ * Reads from:
+ * - `${directory}/opencode.json`
+ * - `${directory}/.opencode/opencode.json`
+ *
+ * Merges ONLY the `qualityGate` key. `.opencode/opencode.json` takes precedence.
+ */
+export async function loadQualityGateConfig($, directory) {
+    const rootConfigPath = `${directory}/opencode.json`;
+    const dotOpencodeConfigPath = `${directory}/.opencode/opencode.json`;
+    const [rootJson, dotOpencodeJson] = await Promise.all([
+        readJsonFile($, rootConfigPath),
+        readJsonFile($, dotOpencodeConfigPath),
+    ]);
+    const rootQualityGate = rootJson?.qualityGate;
+    const dotOpencodeQualityGate = dotOpencodeJson?.qualityGate;
+    return mergeQualityGateConfig(rootQualityGate, dotOpencodeQualityGate);
+}
+/**
+ * Check if any explicit commands are configured (lint/build/test).
+ * If so, these take priority over ci.sh and discovery.
+ */
+export function hasConfiguredCommands(config) {
+    return !!(config.lint || config.build || config.test);
+}

package/dist/quality-gate-config.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unit tests for quality-gate-config module
+ *
+ * Tests focus on pure functions:
+ * - mergeQualityGateConfig: merges two config objects with deep merge for 'include'
+ * - hasConfiguredCommands: checks if explicit commands are configured
+ * - DEFAULT_QUALITY_GATE: verify default values
+ */
+export {};

package/dist/quality-gate-config.test.js

@@ -0,0 +1,164 @@
+/**
+ * Unit tests for quality-gate-config module
+ *
+ * Tests focus on pure functions:
+ * - mergeQualityGateConfig: merges two config objects with deep merge for 'include'
+ * - hasConfiguredCommands: checks if explicit commands are configured
+ * - DEFAULT_QUALITY_GATE: verify default values
+ */
+import { mergeQualityGateConfig, hasConfiguredCommands, DEFAULT_QUALITY_GATE, } from './quality-gate-config';
+describe('DEFAULT_QUALITY_GATE', () => {
+    it('should have correct default values', () => {
+        expect(DEFAULT_QUALITY_GATE.steps).toEqual(['lint', 'build', 'test']);
+        expect(DEFAULT_QUALITY_GATE.useCiSh).toBe('auto');
+        expect(DEFAULT_QUALITY_GATE.packageManager).toBe('auto');
+        expect(DEFAULT_QUALITY_GATE.cacheSeconds).toBe(30);
+        expect(DEFAULT_QUALITY_GATE.maxOutputLines).toBe(160);
+        expect(DEFAULT_QUALITY_GATE.maxErrorLines).toBe(60);
+        expect(DEFAULT_QUALITY_GATE.include.rustClippy).toBe(true);
+    });
+});
+describe('mergeQualityGateConfig', () => {
+    it('should return empty config when both inputs are undefined', () => {
+        const result = mergeQualityGateConfig(undefined, undefined);
+        expect(result).toEqual({ include: {} });
+    });
+    it('should return root config when dotOpencode is undefined', () => {
+        const root = {
+            lint: 'pnpm lint',
+            cacheSeconds: 60,
+        };
+        const result = mergeQualityGateConfig(root, undefined);
+        expect(result).toEqual({ lint: 'pnpm lint', cacheSeconds: 60, include: {} });
+    });
+    it('should return dotOpencode config when root is undefined', () => {
+        const dotOpencode = {
+            build: 'npm run build',
+            maxOutputLines: 200,
+        };
+        const result = mergeQualityGateConfig(undefined, dotOpencode);
+        expect(result).toEqual({ build: 'npm run build', maxOutputLines: 200, include: {} });
+    });
+    it('should override root values with dotOpencode values', () => {
+        const root = {
+            lint: 'pnpm lint',
+            build: 'pnpm build',
+            cacheSeconds: 30,
+        };
+        const dotOpencode = {
+            lint: 'npm run lint:strict',
+            cacheSeconds: 60,
+        };
+        const result = mergeQualityGateConfig(root, dotOpencode);
+        expect(result.lint).toBe('npm run lint:strict');
+        expect(result.build).toBe('pnpm build');
+        expect(result.cacheSeconds).toBe(60);
+    });
+    it('should deep merge include objects', () => {
+        const root = {
+            include: {
+                rustClippy: false,
+            },
+        };
+        const dotOpencode = {
+            include: {
+                rustClippy: true,
+            },
+        };
+        const result = mergeQualityGateConfig(root, dotOpencode);
+        expect(result.include?.rustClippy).toBe(true);
+    });
+    it('should preserve root include values not overridden by dotOpencode', () => {
+        const root = {
+            include: {
+                rustClippy: true,
+            },
+        };
+        const dotOpencode = {
+            lint: 'custom lint',
+            // No include specified
+        };
+        const result = mergeQualityGateConfig(root, dotOpencode);
+        expect(result.include?.rustClippy).toBe(true);
+        expect(result.lint).toBe('custom lint');
+    });
+    it('should handle all config properties', () => {
+        const root = {
+            lint: 'lint-root',
+            build: 'build-root',
+            test: 'test-root',
+            cwd: './root',
+            steps: ['lint'],
+            useCiSh: 'auto',
+            packageManager: 'npm',
+            cacheSeconds: 30,
+            maxOutputLines: 100,
+            maxErrorLines: 50,
+            include: { rustClippy: false },
+        };
+        const dotOpencode = {
+            lint: 'lint-override',
+            steps: ['lint', 'test'],
+            useCiSh: 'never',
+            include: { rustClippy: true },
+        };
+        const result = mergeQualityGateConfig(root, dotOpencode);
+        expect(result.lint).toBe('lint-override');
+        expect(result.build).toBe('build-root');
+        expect(result.test).toBe('test-root');
+        expect(result.cwd).toBe('./root');
+        expect(result.steps).toEqual(['lint', 'test']);
+        expect(result.useCiSh).toBe('never');
+        expect(result.packageManager).toBe('npm');
+        expect(result.cacheSeconds).toBe(30);
+        expect(result.maxOutputLines).toBe(100);
+        expect(result.maxErrorLines).toBe(50);
+        expect(result.include?.rustClippy).toBe(true);
+    });
+});
+describe('hasConfiguredCommands', () => {
+    it('should return false for empty config', () => {
+        expect(hasConfiguredCommands({})).toBe(false);
+    });
+    it('should return false when only non-command properties are set', () => {
+        const config = {
+            cacheSeconds: 60,
+            maxOutputLines: 200,
+            useCiSh: 'always',
+            packageManager: 'pnpm',
+        };
+        expect(hasConfiguredCommands(config)).toBe(false);
+    });
+    it('should return true when lint is configured', () => {
+        const config = {
+            lint: 'pnpm lint',
+        };
+        expect(hasConfiguredCommands(config)).toBe(true);
+    });
+    it('should return true when build is configured', () => {
+        const config = {
+            build: 'pnpm build',
+        };
+        expect(hasConfiguredCommands(config)).toBe(true);
+    });
+    it('should return true when test is configured', () => {
+        const config = {
+            test: 'pnpm test',
+        };
+        expect(hasConfiguredCommands(config)).toBe(true);
+    });
+    it('should return true when multiple commands are configured', () => {
+        const config = {
+            lint: 'pnpm lint',
+            build: 'pnpm build',
+            test: 'pnpm test',
+        };
+        expect(hasConfiguredCommands(config)).toBe(true);
+    });
+    it('should return false for empty string commands', () => {
+        const config = {
+            lint: '',
+        };
+        expect(hasConfiguredCommands(config)).toBe(false);
+    });
+});

package/dist/stop-quality-gate.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput, Hooks } from '@opencode-ai/plugin';
+export declare const SECRET_PATTERNS: Array<{
+    pattern: RegExp;
+    replacement: string;
+}>;
+/**
+ * Sanitizes CI output by redacting common secret patterns before sending to the LLM.
+ * This helps prevent accidental exposure of sensitive information in prompts.
+ */
+export declare function sanitizeOutput(output: string): string;
+/**
+ * Truncates CI output to the last N lines to reduce prompt size and focus on relevant errors.
+ * Adds a header indicating truncation if the output was longer than the limit.
+ */
+export declare function truncateOutput(output: string, maxLines?: number): string;
+export declare function createQualityGateHooks(input: PluginInput): Promise<Partial<Hooks>>;