@soleri/core 9.7.2 → 9.8.0

package/src/enforcement/adapters/opencode.test.ts

@@ -0,0 +1,404 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { OpenCodeAdapter } from './opencode.js';
+import type { EnforcementAction, EnforcementRule } from '../types.js';
+
+// Mock node:fs so detectHost() doesn't hit real filesystem
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return { ...actual, existsSync: vi.fn(() => false) };
+});
+
+import { existsSync } from 'node:fs';
+import { detectHost, createHostAdapter } from './index.js';
+
+const mockedExistsSync = vi.mocked(existsSync);
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+function makeRule(overrides: Partial<EnforcementRule> = {}): EnforcementRule {
+  return {
+    id: 'test-rule',
+    description: 'Test rule',
+    trigger: 'pre-tool-use',
+    action: 'block',
+    message: 'Blocked',
+    ...overrides,
+  };
+}
+
+// ─── OpenCodeAdapter ──────────────────────────────────────────────
+
+describe('OpenCodeAdapter', () => {
+  const adapter = new OpenCodeAdapter();
+
+  // ─── supports() ─────────────────────────────────────────────────
+
+  describe('supports', () => {
+    it('returns true for pre-tool-use', () => {
+      expect(adapter.supports('pre-tool-use')).toBe(true);
+    });
+
+    it('returns true for post-tool-use', () => {
+      expect(adapter.supports('post-tool-use')).toBe(true);
+    });
+
+    it('returns true for pre-compact', () => {
+      expect(adapter.supports('pre-compact')).toBe(true);
+    });
+
+    it('returns true for session-start', () => {
+      expect(adapter.supports('session-start')).toBe(true);
+    });
+
+    it('returns false for pre-commit', () => {
+      expect(adapter.supports('pre-commit')).toBe(false);
+    });
+
+    it('returns false for on-save', () => {
+      expect(adapter.supports('on-save')).toBe(false);
+    });
+  });
+
+  // ─── translate() — empty config ─────────────────────────────────
+
+  describe('translate with empty config', () => {
+    it('returns empty files array when no rules provided', () => {
+      const result = adapter.translate({ rules: [] });
+      expect(result.host).toBe('opencode');
+      expect(result.files).toHaveLength(0);
+      expect(result.skipped).toHaveLength(0);
+    });
+  });
+
+  // ─── translate() — config generation format ─────────────────────
+
+  describe('translate config generation', () => {
+    it('generates plugin file at .opencode/plugins/soleri-enforcement.ts', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'r1', trigger: 'pre-tool-use', pattern: 'test' })],
+      });
+
+      expect(result.files).toHaveLength(1);
+      expect(result.files[0].path).toBe('.opencode/plugins/soleri-enforcement.ts');
+    });
+
+    it('includes auto-generated header comment', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'r1', trigger: 'pre-tool-use', pattern: 'test' })],
+      });
+
+      expect(result.files[0].content).toContain('Auto-generated');
+      expect(result.files[0].content).toContain('do not edit manually');
+    });
+
+    it('exports a default object with hooks', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'r1', trigger: 'pre-tool-use', pattern: 'test' })],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('export default {');
+      expect(content).toContain('hooks: {');
+    });
+
+    it('maps pre-tool-use to tool.execute.before event', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ trigger: 'pre-tool-use', pattern: 'test' })],
+      });
+
+      expect(result.files[0].content).toContain("'tool.execute.before'");
+    });
+
+    it('maps post-tool-use to tool.execute.after event', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ trigger: 'post-tool-use', pattern: 'test' })],
+      });
+
+      expect(result.files[0].content).toContain("'tool.execute.after'");
+    });
+
+    it('maps pre-compact to session.compacted event', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ trigger: 'pre-compact', pattern: 'test' })],
+      });
+
+      expect(result.files[0].content).toContain("'session.compacted'");
+    });
+
+    it('maps session-start to session.created event', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ trigger: 'session-start', pattern: 'test' })],
+      });
+
+      expect(result.files[0].content).toContain("'session.created'");
+    });
+
+    it('groups handlers by event when multiple rules share a trigger', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({
+            id: 'r1',
+            trigger: 'pre-tool-use',
+            pattern: 'foo',
+            action: 'block',
+            message: 'No foo',
+          }),
+          makeRule({
+            id: 'r2',
+            trigger: 'pre-tool-use',
+            pattern: 'bar',
+            action: 'warn',
+            message: 'No bar',
+          }),
+        ],
+      });
+
+      const content = result.files[0].content;
+      // Should have only one 'tool.execute.before' event entry with both checks
+      const eventMatches = content.match(/tool\.execute\.before/g);
+      expect(eventMatches).toHaveLength(1);
+      expect(content).toContain('r1');
+      expect(content).toContain('r2');
+    });
+  });
+
+  // ─── translate() — block/warn/suggest actions ───────────────────
+
+  describe('action code generation', () => {
+    it('block action generates throw new Error', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({ id: 'no-exec', action: 'block', message: 'Do not execute', pattern: 'exec' }),
+        ],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('throw new Error');
+      expect(content).toContain('[no-exec] BLOCKED: Do not execute');
+    });
+
+    it('warn action generates console.warn', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({ id: 'risky', action: 'warn', message: 'Risky operation', pattern: 'risk' }),
+        ],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('console.warn');
+      expect(content).toContain('[risky] WARNING: Risky operation');
+    });
+
+    it('suggest action generates console.info', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({ id: 'tip', action: 'suggest', message: 'Consider this', pattern: 'maybe' }),
+        ],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('console.info');
+      expect(content).toContain('[tip] SUGGESTION: Consider this');
+    });
+
+    it('unknown action falls back to console.warn', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({
+            id: 'unk',
+            action: 'unknown' as unknown as EnforcementAction,
+            message: 'Fallback msg',
+            pattern: 'x',
+          }),
+        ],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('console.warn');
+      expect(content).toContain('[unk] Fallback msg');
+    });
+
+    it('rules without pattern generate action code without regex test', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'always', action: 'block', message: 'Always block' })],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('throw new Error');
+      expect(content).not.toContain('.test(');
+    });
+
+    it('rules with pattern generate regex test against ctx.input', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'pat', action: 'warn', message: 'Match found', pattern: 'danger' })],
+      });
+
+      const content = result.files[0].content;
+      expect(content).toContain('/danger/.test(JSON.stringify(ctx.input');
+    });
+  });
+
+  // ─── translate() — skipped triggers ─────────────────────────────
+
+  describe('skipped triggers', () => {
+    it('skips pre-commit with reason', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'commit-check', trigger: 'pre-commit' })],
+      });
+
+      expect(result.files).toHaveLength(0);
+      expect(result.skipped).toHaveLength(1);
+      expect(result.skipped[0].ruleId).toBe('commit-check');
+      expect(result.skipped[0].reason).toContain('not supported by OpenCode');
+    });
+
+    it('skips on-save with reason', () => {
+      const result = adapter.translate({
+        rules: [makeRule({ id: 'save-check', trigger: 'on-save' })],
+      });
+
+      expect(result.files).toHaveLength(0);
+      expect(result.skipped).toHaveLength(1);
+      expect(result.skipped[0].ruleId).toBe('save-check');
+      expect(result.skipped[0].reason).toContain('not supported by OpenCode');
+    });
+
+    it('handles mix of supported and unsupported triggers', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({ id: 'ok', trigger: 'pre-tool-use', pattern: 'test' }),
+          makeRule({ id: 'skip1', trigger: 'pre-commit' }),
+          makeRule({ id: 'skip2', trigger: 'on-save' }),
+        ],
+      });
+
+      expect(result.files).toHaveLength(1);
+      expect(result.skipped).toHaveLength(2);
+      expect(result.skipped.map((s) => s.ruleId)).toEqual(['skip1', 'skip2']);
+    });
+
+    it('returns only skipped items when all rules are unsupported', () => {
+      const result = adapter.translate({
+        rules: [
+          makeRule({ id: 's1', trigger: 'pre-commit' }),
+          makeRule({ id: 's2', trigger: 'on-save' }),
+        ],
+      });
+
+      expect(result.files).toHaveLength(0);
+      expect(result.skipped).toHaveLength(2);
+    });
+  });
+
+  // ─── host property ──────────────────────────────────────────────
+
+  describe('host', () => {
+    it('identifies as opencode', () => {
+      expect(adapter.host).toBe('opencode');
+    });
+  });
+});
+
+// ─── detectHost() ─────────────────────────────────────────────────
+
+describe('detectHost', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    // Clear relevant env vars before each test
+    delete process.env.OPENCODE;
+    delete process.env.OPENCODE_SESSION;
+    delete process.env.CLAUDE_CODE;
+    mockedExistsSync.mockReset().mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it('returns opencode when OPENCODE env var is set and no Claude indicators', () => {
+    process.env.OPENCODE = '1';
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(detectHost()).toBe('opencode');
+  });
+
+  it('returns opencode when OPENCODE_SESSION env var is set and no Claude indicators', () => {
+    process.env.OPENCODE_SESSION = 'abc123';
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(detectHost()).toBe('opencode');
+  });
+
+  it('returns claude-code when CLAUDE_CODE env var is set and no OpenCode indicators', () => {
+    process.env.CLAUDE_CODE = '1';
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(detectHost()).toBe('claude-code');
+  });
+
+  it('returns claude-code when both OpenCode and Claude indicators present', () => {
+    process.env.OPENCODE = '1';
+    process.env.CLAUDE_CODE = '1';
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(detectHost()).toBe('claude-code');
+  });
+
+  it('returns claude-code when neither host is detected (default)', () => {
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(detectHost()).toBe('claude-code');
+  });
+
+  it('detects opencode via filesystem config when env vars absent', () => {
+    mockedExistsSync.mockImplementation((p: unknown) => {
+      const path = String(p);
+      if (path.includes('opencode/opencode.json')) return true;
+      if (path.includes('.claude')) return false;
+      return false;
+    });
+
+    expect(detectHost()).toBe('opencode');
+  });
+
+  it('detects claude-code via filesystem when .claude dir exists', () => {
+    mockedExistsSync.mockImplementation((p: unknown) => {
+      const path = String(p);
+      if (path.includes('.claude')) return true;
+      return false;
+    });
+
+    expect(detectHost()).toBe('claude-code');
+  });
+});
+
+// ─── createHostAdapter() ──────────────────────────────────────────
+
+describe('createHostAdapter', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    delete process.env.OPENCODE;
+    delete process.env.OPENCODE_SESSION;
+    delete process.env.CLAUDE_CODE;
+    mockedExistsSync.mockReset().mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it('returns OpenCodeAdapter when opencode is detected', () => {
+    process.env.OPENCODE = '1';
+
+    const adapter = createHostAdapter();
+    expect(adapter.host).toBe('opencode');
+    expect(adapter).toBeInstanceOf(OpenCodeAdapter);
+  });
+
+  it('returns ClaudeCodeAdapter by default', () => {
+    const adapter = createHostAdapter();
+    expect(adapter.host).toBe('claude-code');
+  });
+});

package/src/enforcement/adapters/opencode.ts

@@ -0,0 +1,153 @@
+/**
+ * OpenCode host adapter — translates enforcement rules to OpenCode plugin config.
+ *
+ * Maps:
+ * - pre-tool-use → tool.execute.before
+ * - post-tool-use → tool.execute.after
+ * - pre-compact → session.compacted
+ * - session-start → session.created
+ *
+ * Unsupported: pre-commit, on-save (no OpenCode hook equivalents).
+ */
+
+import type {
+  EnforcementConfig,
+  EnforcementTrigger,
+  HostAdapter,
+  HostAdapterResult,
+} from '../types.js';
+
+const TRIGGER_TO_EVENT: Partial<Record<EnforcementTrigger, string>> = {
+  'pre-tool-use': 'tool.execute.before',
+  'post-tool-use': 'tool.execute.after',
+  'pre-compact': 'session.compacted',
+  'session-start': 'session.created',
+};
+
+interface HookHandler {
+  event: string;
+  ruleId: string;
+  pattern?: string;
+  action: string;
+  message: string;
+}
+
+export class OpenCodeAdapter implements HostAdapter {
+  readonly host = 'opencode';
+
+  supports(trigger: EnforcementTrigger): boolean {
+    return trigger in TRIGGER_TO_EVENT;
+  }
+
+  translate(config: EnforcementConfig): HostAdapterResult {
+    const handlers: HookHandler[] = [];
+    const skipped: Array<{ ruleId: string; reason: string }> = [];
+
+    for (const rule of config.rules) {
+      if (!this.supports(rule.trigger)) {
+        skipped.push({
+          ruleId: rule.id,
+          reason: `Trigger '${rule.trigger}' not supported by OpenCode`,
+        });
+        continue;
+      }
+
+      const event = TRIGGER_TO_EVENT[rule.trigger];
+      if (!event) {
+        skipped.push({
+          ruleId: rule.id,
+          reason: `No event mapping for '${rule.trigger}'`,
+        });
+        continue;
+      }
+
+      handlers.push({
+        event,
+        ruleId: rule.id,
+        pattern: rule.pattern,
+        action: rule.action,
+        message: rule.message,
+      });
+    }
+
+    const files: Array<{ path: string; content: string }> = [];
+
+    if (handlers.length > 0) {
+      files.push({
+        path: '.opencode/plugins/soleri-enforcement.ts',
+        content: this.generatePluginFile(handlers),
+      });
+    }
+
+    return { host: this.host, files, skipped };
+  }
+
+  private generatePluginFile(handlers: HookHandler[]): string {
+    // Group handlers by event
+    const byEvent = new Map<string, HookHandler[]>();
+    for (const h of handlers) {
+      const existing = byEvent.get(h.event) ?? [];
+      existing.push(h);
+      byEvent.set(h.event, existing);
+    }
+
+    const hookEntries: string[] = [];
+
+    for (const [event, eventHandlers] of Array.from(byEvent.entries())) {
+      const checks = eventHandlers.map((h) => this.generateCheck(h)).join('\n');
+      hookEntries.push(`  '${event}': (ctx) => {\n${checks}\n  }`);
+    }
+
+    const lines = [
+      '/**',
+      ' * Soleri enforcement plugin for OpenCode.',
+      ' * Auto-generated — do not edit manually.',
+      ' */',
+      '',
+      'export default {',
+      '  hooks: {',
+      hookEntries.join(',\n'),
+      '  },',
+      '};',
+      '',
+    ];
+
+    return lines.join('\n');
+  }
+
+  private generateCheck(handler: HookHandler): string {
+    const indent = '    ';
+
+    if (!handler.pattern) {
+      // No pattern — always fires
+      return this.generateActionCode(indent, handler.ruleId, handler.action, handler.message);
+    }
+
+    // Pattern-based check
+    const lines = [
+      `${indent}// Rule: ${handler.ruleId}`,
+      `${indent}if (/${handler.pattern}/.test(JSON.stringify(ctx.input ?? ''))) {`,
+      this.generateActionCode(`${indent}  `, handler.ruleId, handler.action, handler.message),
+      `${indent}}`,
+    ];
+    return lines.join('\n');
+  }
+
+  private generateActionCode(
+    indent: string,
+    ruleId: string,
+    action: string,
+    message: string,
+  ): string {
+    switch (action) {
+      case 'block':
+        return `${indent}throw new Error('[${ruleId}] BLOCKED: ${message}');`;
+      case 'warn':
+        return `${indent}console.warn('[${ruleId}] WARNING: ${message}');`;
+      case 'suggest':
+        return `${indent}console.info('[${ruleId}] SUGGESTION: ${message}');`;
+      default:
+        return `${indent}console.warn('[${ruleId}] ${message}');`;
+    }
+  }
+}

package/src/planning/evidence-collector.test.ts

@@ -340,6 +340,101 @@ describe('collectGitEvidence', () => {
   });
 });
 
+describe('collectGitEvidence — rework tracking', () => {
+  it('includes fixIterations in task evidence when present', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          fixIterations: 2,
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.taskEvidence[0].fixIterations).toBe(2);
+  });
+
+  it('omits fixIterations when task has zero rework', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.taskEvidence[0].fixIterations).toBeUndefined();
+  });
+
+  it('includes rework count in summary when tasks were reworked', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\nM\tsrc/auth/login.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          fixIterations: 1,
+          updatedAt: Date.now(),
+        },
+        {
+          id: 'task-2',
+          title: 'Add login endpoint',
+          description: 'Login endpoint',
+          status: 'completed',
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.summary).toContain('1 required rework');
+  });
+
+  it('does not include rework in summary when no tasks were reworked', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.summary).not.toContain('rework');
+  });
+});
+
 describe('collectVerificationGaps', () => {
   it('returns empty array when no tasks have verification', () => {
     const tasks: PlanTask[] = [makeTask()];

package/src/planning/evidence-collector.ts

@@ -19,6 +19,8 @@ export interface GitTaskEvidence {
   plannedStatus: string;
   matchedFiles: FileChange[];
   verdict: 'DONE' | 'PARTIAL' | 'MISSING' | 'SKIPPED';
+  /** Number of rework cycles this task went through (0 = first pass). */
+  fixIterations?: number;
 }
 
 export interface UnplannedChange {
@@ -72,6 +74,8 @@ export function collectGitEvidence(
       plannedStatus: task.status,
       matchedFiles: matches,
       verdict,
+      ...(task.fixIterations !== undefined &&
+        task.fixIterations > 0 && { fixIterations: task.fixIterations }),
     });
   }
 
@@ -93,12 +97,17 @@ export function collectGitEvidence(
       ? Math.round(((doneTasks + partialTasks * 0.5 + skippedTasks * 0.25) / totalTasks) * 100)
       : 100;
 
+  const reworkedTasks = taskEvidence.filter(
+    (te) => te.fixIterations && te.fixIterations > 0,
+  ).length;
+
   const summary = buildSummary(
     totalTasks,
     doneTasks,
     partialTasks,
     missingWork.length,
     unplannedChanges.length,
+    reworkedTasks,
   );
 
   const verificationGaps = collectVerificationGaps(plan.tasks, taskEvidence);
@@ -284,11 +293,13 @@ function buildSummary(
   partial: number,
   missing: number,
   unplanned: number,
+  reworked: number = 0,
 ): string {
   const parts: string[] = [];
   parts.push(`${done}/${total} tasks verified by git evidence`);
   if (partial > 0) parts.push(`${partial} partially done`);
   if (missing > 0) parts.push(`${missing} with no file evidence`);
   if (unplanned > 0) parts.push(`${unplanned} unplanned file changes`);
+  if (reworked > 0) parts.push(`${reworked} required rework`);
   return parts.join(', ');
 }