openlore 2.0.0

package/examples/opencode/plugins/openlore-context-injector.ts

@@ -0,0 +1,165 @@
+/**
+ * openlore-context-injector.ts
+ *
+ * Plugin OpenCode : injection des spécifications OpenSpec dans le contexte
+ * Sisyphus pour fermer le triangle SDD (Specs ↔ Tests ↔ Code).
+ *
+ * Problème résolu :
+ *   Les plugins enforcer et decision-extractor agissent APRÈS le code.
+ *   Sisyphus ne lit pas les specs AVANT de coder, ce qui crée un risque de
+ *   dérive silencieuse. Ce plugin injecte la vérité architecturale du projet
+ *   dans chaque tour de conversation.
+ *
+ * Mécanisme :
+ *   1. experimental.chat.system.transform — injecte à chaque tour un index
+ *      compact des domaines OpenSpec disponibles (quelques lignes, faible coût).
+ *   2. tool.execute.after — détecte les fichiers écrits et mappe leur domaine
+ *      OpenSpec pour savoir quels specs sont "actifs" dans la session.
+ *   3. experimental.session.compacting — injecte le contenu complet des specs
+ *      actives lors des compactions pour préserver la connaissance des contrats.
+ *
+ * Placer dans : .opencode/plugins/openlore-context-injector.ts
+ */
+
+import type { Plugin } from '@opencode-ai/plugin';
+import {
+  loadSpecDomains,
+  readSpec,
+  fileToSpecDomain,
+  MAX_FULL_SPECS,
+} from './lib/openlore-context-injector-helpers.ts';
+import type { SpecDomain } from './lib/openlore-context-injector-helpers.ts';
+
+// ─── Plugin ──────────────────────────────────────────────────────────────────
+
+export const OpenLoreContextInjector: Plugin = async (_ctx: any) => {
+  // Domaines actifs dans la session courante (fichiers écrits par l'agent)
+  // Map sessionID → Set<domainName>
+  const activeDomains = new Map<string, Set<string>>();
+
+  // Cache de l'index des domaines (rechargé si les specs changent)
+  let domainsCache: SpecDomain[] | null = null;
+  let domainsCacheTime = 0;
+  const CACHE_TTL_MS = 30_000;
+
+  function getDomains(): SpecDomain[] {
+    const now = Date.now();
+    if (!domainsCache || now - domainsCacheTime > CACHE_TTL_MS) {
+      domainsCache = loadSpecDomains();
+      domainsCacheTime = now;
+    }
+    return domainsCache;
+  }
+
+  return {
+    // ── 1. Index compact injecté à chaque tour ────────────────────────────────
+    //
+    // input: { sessionID?, model }
+    // output: { system: string[] } — mutable (push des lignes)
+    //
+    // On injecte un tableau compact des domaines disponibles : quelques lignes
+    // suffisent pour que Sisyphus sache quoi chercher avec get_spec/search_specs.
+    //
+    'experimental.chat.system.transform': async (_input: any, output: any) => {
+      const domains = getDomains();
+      if (domains.length === 0) return;
+
+      const index = [
+        '## OpenSpec Contracts — read before modifying any module',
+        '',
+        'This project has structured specifications. Check the relevant spec BEFORE changing a module.',
+        '',
+        '| Domain | Purpose |',
+        '|--------|---------|',
+        ...domains.map(
+          (d) => `| \`${d.name}\` | ${d.purpose.slice(0, 80)}${d.purpose.length > 80 ? '…' : ''} |`
+        ),
+        '',
+        'Tools: `get_spec <domain>` · `search_specs <query>` · `check_spec_drift` after changes',
+      ].join('\n');
+
+      output.system.push(index);
+    },
+
+    // ── 2. Tracking des domaines actifs dans la session ───────────────────────
+    //
+    // input: { tool, sessionID, callID, args }
+    // output: { title, output, metadata }
+    //
+    'tool.execute.after': async (input: any) => {
+      const isFileWrite = [
+        'write_file',
+        'create_file',
+        'str_replace_based_edit_tool',
+        'edit',
+      ].includes(input.tool);
+      if (!isFileWrite || !input.sessionID) return;
+
+      const filePath: string = input.args?.path ?? input.args?.file_path ?? '';
+      if (!filePath) return;
+
+      const domains = getDomains();
+      const domain = fileToSpecDomain(filePath, domains);
+      if (!domain) return;
+
+      if (!activeDomains.has(input.sessionID)) {
+        activeDomains.set(input.sessionID, new Set());
+      }
+      activeDomains.get(input.sessionID)!.add(domain);
+    },
+
+    // ── 3. Injection complète des specs actives lors des compactions ──────────
+    //
+    // input: { sessionID }
+    // output: { context: string[], prompt?: string } — mutable
+    //
+    // Contrairement au system.transform (index compact), ici on injecte le
+    // contenu complet des specs des domaines touchés dans la session.
+    // Ça préserve les contrats architecturaux après compression du contexte.
+    //
+    'experimental.session.compacting': async (input: any, output: any) => {
+      const domains = getDomains();
+      if (domains.length === 0) return;
+
+      const sessionActive = activeDomains.get(input.sessionID) ?? new Set<string>();
+
+      // Specs à injecter : d'abord les domaines actifs, puis overview en fallback
+      const toInject: SpecDomain[] = [];
+
+      for (const name of sessionActive) {
+        const d = domains.find((x) => x.name === name);
+        if (d) toInject.push(d);
+        if (toInject.length >= MAX_FULL_SPECS) break;
+      }
+
+      // Toujours inclure overview si pas déjà là
+      const overview = domains.find((d) => d.name === 'overview');
+      if (overview && !toInject.find((d) => d.name === 'overview')) {
+        toInject.unshift(overview);
+      }
+
+      if (toInject.length === 0) return;
+
+      output.context.push(
+        '## Active OpenSpec Contracts — enforce these before coding',
+        '',
+        `Domains active in this session: ${[...sessionActive].join(', ') || '(none yet)'}`,
+        '',
+        ...toInject.flatMap((domain) => {
+          const content = readSpec(domain);
+          if (!content) return [];
+          return [`### Spec: ${domain.name}`, '', content, ''];
+        }),
+        '⚠️  Code changes MUST satisfy the SHALL/MUST requirements above.',
+        'Run `check_spec_drift` after changes to verify alignment.'
+      );
+    },
+
+    // ── Nettoyage session ─────────────────────────────────────────────────────
+    event: async ({ event }: any) => {
+      if (event.type === 'session.deleted') {
+        activeDomains.delete(event.sessionID);
+      }
+    },
+  };
+};

package/examples/opencode/plugins/openlore-decision-extractor.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { scoreFromDepGraph } from './lib/openlore-decision-extractor-helpers.ts';
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+function makeDepGraph(nodes: any[] = []) {
+  return {
+    nodes,
+    edges: [],
+    statistics: { nodeCount: nodes.length, edgeCount: 0 },
+  };
+}
+
+function makeNode(path: string, inDegree = 0, pageRank = 0.1, score = 0.2) {
+  return {
+    id: path,
+    file: { path, score },
+    metrics: { inDegree, outDegree: 0, betweenness: 0, pageRank },
+    exports: [],
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('scoreFromDepGraph', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'openlore-extractor-test-'));
+    await mkdir(join(tmpDir, '.openlore', 'analysis'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns null when dependency-graph.json is missing', () => {
+    const result = scoreFromDepGraph('src/foo.ts', tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when dependency-graph.json is invalid JSON', async () => {
+    await writeFile(join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'), 'not json');
+    const result = scoreFromDepGraph('src/foo.ts', tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when file is not in the graph', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('src/other.ts')]))
+    );
+    const result = scoreFromDepGraph('src/foo.ts', tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('finds a node by exact path', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('src/foo.ts', 2, 0.3, 0.5)]))
+    );
+    const result = scoreFromDepGraph('src/foo.ts', tmpDir);
+    expect(result).not.toBeNull();
+    expect(result!.inDegree).toBe(2);
+    expect(result!.pageRank).toBeCloseTo(0.3);
+    expect(result!.fileScore).toBeCloseTo(0.5);
+  });
+
+  it('finds a node by path suffix', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('/absolute/project/src/foo.ts', 1, 0.2, 0.4)]))
+    );
+    const result = scoreFromDepGraph('src/foo.ts', tmpDir);
+    expect(result).not.toBeNull();
+    expect(result!.inDegree).toBe(1);
+  });
+
+  it('marks a node as hub when inDegree is high', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('src/hub.ts', 5, 0.1, 0.2)]))
+    );
+    const result = scoreFromDepGraph('src/hub.ts', tmpDir);
+    expect(result!.isHub).toBe(true);
+  });
+
+  it('marks a node as hub when pageRank is high', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('src/central.ts', 0, 0.6, 0.2)]))
+    );
+    const result = scoreFromDepGraph('src/central.ts', tmpDir);
+    expect(result!.isHub).toBe(true);
+  });
+
+  it('marks a node as hub when fileScore is high', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('src/important.ts', 0, 0.1, 0.8)]))
+    );
+    const result = scoreFromDepGraph('src/important.ts', tmpDir);
+    expect(result!.isHub).toBe(true);
+  });
+
+  it('does not mark a low-centrality node as hub', async () => {
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([makeNode('src/leaf.ts', 0, 0.05, 0.1)]))
+    );
+    const result = scoreFromDepGraph('src/leaf.ts', tmpDir);
+    expect(result!.isHub).toBe(false);
+  });
+
+  it('handles missing metrics fields gracefully', async () => {
+    const node = { id: 'src/bare.ts', file: { path: 'src/bare.ts' }, exports: [] };
+    await writeFile(
+      join(tmpDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      JSON.stringify(makeDepGraph([node]))
+    );
+    const result = scoreFromDepGraph('src/bare.ts', tmpDir);
+    expect(result).not.toBeNull();
+    expect(result!.inDegree).toBe(0);
+    expect(result!.pageRank).toBe(0);
+    expect(result!.fileScore).toBe(0);
+    expect(result!.isHub).toBe(false);
+  });
+});

package/examples/opencode/plugins/openlore-decision-extractor.ts

@@ -0,0 +1,322 @@
+/**
+ * openlore-decision-extractor.ts
+ *
+ * Plugin OpenCode : extraction proactive des décisions architecturales.
+ *
+ * Mécanisme :
+ *   1. tool.execute.after — détecte les écritures de fichiers source et
+ *      enregistre les candidats à analyser (avec sessionID).
+ *   2. session.idle — appel HTTP direct au LLM configuré (JSON-only, pas de
+ *      tool calling). Parse la réponse et écrit dans pending.json directement.
+ *      Cooldown 5 min par session pour éviter les spawns répétés.
+ *
+ * Env vars :
+ *   OPENAI_BASE_URL         — défaut: https://codestral.mistral.ai/v1
+ *   OPENAI_API_KEY          — défaut: $MISTRAL_API_KEY
+ *   OPENAI_MODEL_EXTRACTOR  — défaut: devstral-small-latest
+ *
+ * Placer dans : .opencode/plugins/openlore-decision-extractor.ts
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import type { Plugin } from '@opencode-ai/plugin';
+import {
+  scoreFromDepGraph,
+  HUB_INDEGREE,
+  HIGH_PAGERANK,
+  HIGH_FILE_SCORE,
+} from './lib/openlore-decision-extractor-helpers.ts';
+import type { FileScore } from './lib/openlore-decision-extractor-helpers.ts';
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+const EXTRACT_BASE_URL = process.env.OPENAI_BASE_URL ?? 'https://codestral.mistral.ai/v1';
+const EXTRACT_API_KEY = process.env.OPENAI_API_KEY ?? process.env.MISTRAL_API_KEY ?? '';
+const EXTRACT_MODEL = process.env.OPENAI_MODEL_EXTRACTOR ?? 'devstral-small-latest';
+
+const OPENLORE_BIN = resolveOpenLore();
+
+function resolveOpenLore(): string {
+  for (const c of ['node_modules/.bin/openlore', 'dist/cli/index.js']) {
+    try {
+      execSync(`test -f ${c}`, { stdio: 'pipe' });
+      return c.endsWith('.js') ? `node ${c}` : c;
+    } catch {}
+  }
+  return 'openlore';
+}
+
+// Fichiers source à surveiller
+const SOURCE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|rb|java|cpp|c|h)$/;
+const SKIP_PATTERN =
+  /\.(test|spec|stories|mock|fixture)\.[jt]sx?$|\.d\.ts$|\.lock$|\.json$|\.ya?ml$|\.md$|\.env$/;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function parseJSON<T>(raw: string): T | null {
+  try {
+    return JSON.parse(raw.replace(/```json|```/g, '').trim());
+  } catch {
+    return null;
+  }
+}
+
+function run(args: string): string {
+  try {
+    return execSync(`${OPENLORE_BIN} ${args}`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (e: any) {
+    return e.stdout ?? '';
+  }
+}
+
+function getActiveDecisions(): any[] {
+  return parseJSON<any[]>(run('decisions --list --json')) ?? [];
+}
+
+function getSpecDomains(): string[] {
+  try {
+    return execSync('ls openspec/specs/', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+      .split('\n')
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function isSource(filePath: string): boolean {
+  return SOURCE_PATTERN.test(filePath) && !SKIP_PATTERN.test(filePath);
+}
+
+function alreadyCovered(filePath: string): boolean {
+  return getActiveDecisions().some((d) => (d.affectedFiles ?? []).includes(filePath));
+}
+
+// Prompt envoyé au Librarian (ou au fallback LLM)
+function buildPrompt(filePath: string, content: string, score: FileScore | null): string {
+  const domains = getSpecDomains();
+
+  const scoreContext = score
+    ? [
+        `STRUCTURAL CONTEXT (from static analysis):`,
+        `  inDegree  : ${score.inDegree} file(s) import this file`,
+        `  pageRank  : ${(score.pageRank * 100).toFixed(0)}% (normalized importance)`,
+        `  fileScore : ${(score.fileScore * 100).toFixed(0)}% (significance score)`,
+        score.isHub
+          ? `  → This is a HUB file. Lean toward recording a decision.`
+          : `  → Low centrality. Only record if clearly architectural.`,
+      ].join('\n')
+    : `STRUCTURAL CONTEXT: File not found in dep-graph (new file — treat as potentially architectural).`;
+
+  return [
+    `You are an architectural decision detector for a spec-driven development project.`,
+    ``,
+    `FILE: ${filePath}`,
+    `KNOWN SPEC DOMAINS: ${domains.join(', ') || 'unknown'}`,
+    ``,
+    scoreContext,
+    ``,
+    `NEW CONTENT (first 800 chars):`,
+    content.slice(0, 800),
+    ``,
+    `TASK: Determine if this file change represents an architectural decision.`,
+    ``,
+    `Architectural = any of:`,
+    `- Module responsibility change`,
+    `- New pattern or abstraction introduced`,
+    `- Communication or data flow change`,
+    `- New external dependency`,
+    `- Error handling strategy change`,
+    `- Performance trade-off with downstream consequences`,
+    ``,
+    `NOT architectural = formatting, renaming, trivial bug fixes, test additions, config values.`,
+    ``,
+    `If architectural: respond with ONLY this JSON object (no explanation, no markdown):`,
+    `{"title":"<max 10 words>","rationale":"<2-3 sentences>","affectedDomains":["<domain>"],"affectedFiles":["${filePath}"],"consequences":"<1-2 sentences>"}`,
+    ``,
+    `If NOT architectural: respond with ONLY the string: NOT_ARCHITECTURAL`,
+    ``,
+    `Do not call any tools. Do not explain. Respond with JSON or NOT_ARCHITECTURAL only.`,
+  ].join('\n');
+}
+
+// ─── Extraction HTTP + écriture pending.json ─────────────────────────────────
+
+function writeToPending(decision: any, sessionId: string, rootDir = process.cwd()): void {
+  const dir = join(rootDir, '.openlore', 'decisions');
+  const file = join(dir, 'pending.json');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const store = existsSync(file)
+    ? (parseJSON<any>(readFileSync(file, 'utf-8')) ?? { version: '1', decisions: [] })
+    : { version: '1', decisions: [] };
+
+  const id = createHash('sha256')
+    .update(`${sessionId}:${decision.title}`)
+    .digest('hex')
+    .slice(0, 8);
+
+  store.decisions.push({
+    id,
+    status: 'draft',
+    title: decision.title,
+    rationale: decision.rationale,
+    consequences: decision.consequences ?? '',
+    proposedRequirement: null,
+    affectedDomains: decision.affectedDomains ?? [],
+    affectedFiles: decision.affectedFiles ?? [],
+    confidence: 'medium',
+    sessionId,
+    recordedAt: new Date().toISOString(),
+    syncedToSpecs: [],
+  });
+
+  store.updatedAt = new Date().toISOString();
+  store.sessionId = sessionId;
+  writeFileSync(file, JSON.stringify(store, null, 2));
+}
+
+async function extractAndRecord(
+  filePath: string,
+  content: string,
+  score: FileScore | null,
+  sessionId: string
+): Promise<void> {
+  if (!EXTRACT_API_KEY) return;
+
+  const prompt = buildPrompt(filePath, content, score);
+
+  try {
+    const res = await fetch(`${EXTRACT_BASE_URL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${EXTRACT_API_KEY}`,
+      },
+      body: JSON.stringify({
+        model: EXTRACT_MODEL,
+        messages: [{ role: 'user', content: prompt }],
+        temperature: 0.1,
+        max_tokens: 300,
+      }),
+    });
+
+    if (!res.ok) return;
+
+    const data = await res.json();
+    const text: string = (data?.choices?.[0]?.message?.content ?? '').trim();
+
+    if (text === 'NOT_ARCHITECTURAL' || text.startsWith('NOT_ARCHITECTURAL')) return;
+
+    const decision = parseJSON<any>(text);
+    if (!decision?.title) return;
+
+    writeToPending(decision, sessionId);
+
+    await (globalThis as any).__opencode_client?.app?.log?.({
+      body: {
+        service: 'decision-extractor',
+        level: 'info',
+        message: `Decision recorded for ${filePath}: "${decision.title}"`,
+      },
+    });
+  } catch {
+    // Non-bloquant
+  }
+}
+
+// ─── Plugin ──────────────────────────────────────────────────────────────────
+
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes entre deux spawns Librarian par session
+
+export const OpenLoreDecisionExtractor: Plugin = async ({ client }) => {
+  // Fichiers en attente d'analyse : filePath → { content, score, sessionID }
+  const pending = new Map<
+    string,
+    { content: string; score: FileScore | null; sessionID: string }
+  >();
+
+  // Cooldown par sessionID : timestamp du dernier appel d'extraction
+  const lastExtract = new Map<string, number>();
+
+  // Rendre le client accessible dans extractAndRecord pour le logging
+  (globalThis as any).__opencode_client = client;
+
+  return {
+    // ── Enrichir record_decision avec les domaines connus ────────────────────
+    'tool.definition': async (input: any, output: any) => {
+      if (input.toolID !== 'record_decision') return;
+      const domains = getSpecDomains();
+      if (domains.length === 0) return;
+      output.description =
+        (output.description ?? '') +
+        `\n\nKnown spec domains: ${domains.join(', ')}. Use these exact names in affectedDomains.`;
+    },
+
+    // ── Collecte des fichiers à analyser ─────────────────────────────────────
+    'tool.execute.after': async (input: any, output: any) => {
+      const isFileWrite = [
+        'write_file',
+        'create_file',
+        'str_replace_based_edit_tool',
+        'edit',
+      ].includes(input.tool);
+      if (!isFileWrite) return;
+
+      const filePath: string =
+        input.args?.filePath ?? input.args?.path ?? input.args?.file_path ?? '';
+      if (!filePath || !isSource(filePath) || alreadyCovered(filePath)) return;
+
+      const score = scoreFromDepGraph(filePath);
+
+      if (score !== null && score.inDegree === 0 && score.pageRank < 0.1 && score.fileScore < 0.3) {
+        return;
+      }
+
+      let content = '';
+      try {
+        content = readFileSync(filePath, 'utf-8');
+      } catch {}
+      pending.set(filePath, { content, score, sessionID: input.sessionID ?? '' });
+    },
+
+    event: async ({ event }: any) => {
+      // ── Extraction sur idle : appel HTTP direct, pas de Librarian ────────
+      const sid: string = event.properties?.sessionID ?? event.sessionID ?? '';
+      if (event.type === 'session.idle') {
+        if (pending.size === 0) return;
+
+        const now = Date.now();
+        const sinceLastExtract = now - (lastExtract.get(sid) ?? 0);
+        if (sinceLastExtract < COOLDOWN_MS) return;
+
+        const toProcess = [...pending.entries()].filter(([, { sessionID }]) => sessionID === sid);
+
+        if (toProcess.length === 0) return;
+
+        lastExtract.set(sid, now);
+
+        for (const [filePath, { content, score, sessionID }] of toProcess) {
+          pending.delete(filePath);
+          await extractAndRecord(filePath, content, score, sessionID);
+        }
+        return;
+      }
+
+      if (event.type === 'session.deleted') {
+        for (const [filePath, { sessionID }] of pending) {
+          if (sessionID === sid) pending.delete(filePath);
+        }
+        lastExtract.delete(sid);
+      }
+    },
+  };
+};