@soleri/core 9.7.2 → 9.9.0

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

@@ -0,0 +1,406 @@
+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) => {
+      // Normalize to forward slashes so the check works on Windows too
+      const path = String(p).replace(/\\/g, '/');
+      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) => {
+      // Normalize to forward slashes so the check works on Windows too
+      const path = String(p).replace(/\\/g, '/');
+      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/index.ts

@@ -40,9 +40,18 @@ export {
   agentKeysPath,
   agentTemplatesDir,
   agentFlagsPath,
+  agentKnowledgeDir,
+  projectKnowledgeDir,
   sharedVaultPath,
 } from './paths.js';
 
+// ─── Vault Markdown Sync ───────────────────────────────────────────
+export {
+  syncAllToMarkdown,
+  syncEntryToMarkdown,
+  entryToMarkdown,
+} from './vault/vault-markdown-sync.js';
+
 // ─── Intelligence ────────────────────────────────────────────────────
 export type {
   IntelligenceEntry,
@@ -901,6 +910,16 @@ export type {
   DeclinedCategory,
 } from './operator/operator-context-types.js';
 
+// ─── Workflows ─────────────────────────────────────────────────────────
+export {
+  WorkflowGateSchema,
+  WorkflowOverrideSchema,
+  WORKFLOW_TO_INTENT,
+  loadAgentWorkflows,
+  getWorkflowForIntent,
+} from './workflows/index.js';
+export type { WorkflowGate, WorkflowOverride } from './workflows/index.js';
+
 // ─── Update Check ────────────────────────────────────────────────────
 export { checkForUpdate, buildChangelogUrl, detectBreakingChanges } from './update-check.js';
 export type { UpdateInfo } from './update-check.js';

package/src/paths.ts

@@ -109,6 +109,11 @@ export function agentKnowledgeDir(agentId: string): string {
   return join(agentHome(agentId), 'knowledge');
 }
 
+/** Project-local knowledge directory for browsable markdown sync. */
+export function projectKnowledgeDir(projectPath: string): string {
+  return join(projectPath, 'knowledge');
+}
+
 /** Shared vault path: ~/.soleri/vault.db (cross-agent intelligence) */
 export function sharedVaultPath(): string {
   return join(SOLERI_HOME, 'vault.db');