openlore 2.0.0

package/examples/opencode/plugins/anti-laziness.ts

@@ -0,0 +1,202 @@
+/**
+ * anti-laziness.ts
+ *
+ * Plugin OpenCode — Prévention de l'arrêt prématuré sur tâches longues.
+ *
+ * Problème ciblé :
+ *   Mistral Small / Devstral s'arrêtent dès qu'une sous-tâche est terminée
+ *   même si le plan global n'est pas terminé.
+ *
+ * Mécanisme :
+ *   1. `todo.updated` event → capture le plan dès que l'agent le crée/met à jour.
+ *   2. `session.idle` event → au moment où l'agent s'arrête, vérifie si des
+ *      tâches sont incomplètes et réinjecte un prompt de continuation.
+ *   3. `experimental.session.compacting` → préserve le plan en mémoire lors des
+ *      compactions de contexte pour éviter que l'agent oublie ses tâches.
+ *
+ * Safeguards :
+ *   - MAX_CONTINUATIONS : évite une boucle infinie si le modèle est bloqué.
+ *   - IDLE_DEBOUNCE_MS : ignore les idle très courts (transitions internes).
+ *
+ * Placer dans : .opencode/plugins/anti-laziness.ts
+ */
+
+import type { Plugin } from "@opencode-ai/plugin"
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+const MAX_CONTINUATIONS = 8
+const IDLE_DEBOUNCE_MS = 1500
+const IDLE_CHECK_DELAY_MS = 800
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface TodoItem {
+  id: string
+  content: string
+  status: "pending" | "in_progress" | "completed"
+  priority?: "high" | "medium" | "low"
+}
+
+interface SessionState {
+  plan: TodoItem[]
+  continuationCount: number
+  lastIdleAt: number
+}
+
+// ─── Plugin ──────────────────────────────────────────────────────────────────
+
+export const AntiLazinessPlugin: Plugin = async ({ client }) => {
+  const sessions = new Map<string, SessionState>()
+
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+
+  function getOrCreate(sessionId: string): SessionState {
+    if (!sessions.has(sessionId)) {
+      sessions.set(sessionId, { plan: [], continuationCount: 0, lastIdleAt: 0 })
+    }
+    return sessions.get(sessionId)!
+  }
+
+  function pendingTasks(state: SessionState): TodoItem[] {
+    return state.plan.filter(t => t.status === "pending" || t.status === "in_progress")
+  }
+
+  function buildContinuationPrompt(state: SessionState, pending: TodoItem[]): string {
+    const done = state.plan.filter(t => t.status === "completed")
+    const pendingList = pending
+      .map((t, i) => {
+        const marker = t.status === "in_progress" ? "⏳" : "◻"
+        return `  ${marker} ${i + 1}. ${t.content}${t.priority ? ` [${t.priority}]` : ""}`
+      })
+      .join("\n")
+    const doneList = done.length > 0
+      ? done.map(t => `  ✓ ${t.content}`).join("\n")
+      : "  (none yet)"
+
+    return [
+      `⚠️  TASK NOT COMPLETE — Continuation required (${state.continuationCount + 1}/${MAX_CONTINUATIONS})`,
+      ``,
+      `Progress: ${done.length}/${state.plan.length} tasks completed.`,
+      ``,
+      `Completed:`,
+      doneList,
+      ``,
+      `Still pending (${pending.length} task${pending.length > 1 ? "s" : ""}):`,
+      pendingList,
+      ``,
+      `You stopped before finishing the full plan. Continue immediately with the next pending task.`,
+      `Do NOT summarize or declare "task completed" until ALL tasks above are marked done.`,
+      `Start with the first ◻ task now.`,
+    ].join("\n")
+  }
+
+  // ─── Hooks ─────────────────────────────────────────────────────────────────
+
+  return {
+    // ── 1. Capture du plan via l'event todo.updated ──────────────────────────
+    //
+    // OpenCode émet todo.updated chaque fois que l'agent crée ou met à jour
+    // sa todo list — plus fiable que d'intercepter tool.execute.after sur todowrite.
+    //
+    event: async ({ event }: any) => {
+      // Capture / mise à jour du plan
+      if (event.type === "todo.updated") {
+        const state = getOrCreate(event.sessionID)
+        state.plan = (event.todos ?? []) as TodoItem[]
+        await client.app.log({
+          body: {
+            service: "anti-laziness",
+            level: "info",
+            message: `Plan updated: ${state.plan.length} tasks, ${pendingTasks(state).length} pending`,
+          },
+        })
+        return
+      }
+
+      // ── 2. Détection d'arrêt prématuré ──────────────────────────────────
+      if (event.type === "session.idle") {
+        const state = sessions.get(event.sessionID)
+        if (!state || state.plan.length === 0) return
+
+        const now = Date.now()
+        if (now - state.lastIdleAt < IDLE_DEBOUNCE_MS) return
+        state.lastIdleAt = now
+
+        // Laisser le modèle finir d'écrire
+        await new Promise(r => setTimeout(r, IDLE_CHECK_DELAY_MS))
+
+        const pending = pendingTasks(state)
+
+        if (pending.length === 0) {
+          sessions.delete(event.sessionID)
+          await client.app.log({
+            body: { service: "anti-laziness", level: "info",
+              message: `All tasks completed for session ${event.sessionID}` },
+          })
+          return
+        }
+
+        if (state.continuationCount >= MAX_CONTINUATIONS) {
+          await client.app.log({
+            body: { service: "anti-laziness", level: "warn",
+              message: `Max continuations (${MAX_CONTINUATIONS}) reached — human intervention needed`,
+              extra: { pending: pending.map(t => t.content) },
+            },
+          })
+          return
+        }
+
+        state.continuationCount++
+        const prompt = buildContinuationPrompt(state, pending)
+
+        await client.app.log({
+          body: { service: "anti-laziness", level: "info",
+            message: `Injecting continuation ${state.continuationCount}/${MAX_CONTINUATIONS} — ${pending.length} task(s) remaining`,
+          },
+        })
+
+        try {
+          await client.session.prompt({
+            path: { id: event.sessionID },
+            body: { parts: [{ type: "text", text: prompt }] },
+          })
+        } catch (err: any) {
+          await client.app.log({
+            body: { service: "anti-laziness", level: "error",
+              message: `session.prompt failed: ${err.message}` },
+          })
+        }
+        return
+      }
+
+      // ── 3. Nettoyage à la suppression de session ─────────────────────────
+      if (event.type === "session.deleted") {
+        sessions.delete(event.sessionID)
+      }
+    },
+
+    // ── 4. Préserver le plan lors des compactions de contexte ────────────────
+    //
+    // Évite que l'agent oublie ses tâches en cours quand le contexte est compressé.
+    //
+    "experimental.session.compacting": async (input: any, output: any) => {
+      const state = sessions.get(input.sessionID)
+      if (!state || state.plan.length === 0) return
+
+      const pending = pendingTasks(state)
+      if (pending.length === 0) return
+
+      output.context.push(
+        "## ACTIVE TASK PLAN — DO NOT STOP EARLY",
+        "",
+        `Progress: ${state.plan.length - pending.length}/${state.plan.length} tasks done.`,
+        "",
+        "Still pending:",
+        ...pending.map(t => `- [${t.status}] ${t.content}${t.priority ? ` [${t.priority}]` : ""}`),
+        "",
+        "Continue with pending tasks. Do NOT declare the session complete until all tasks are done.",
+      )
+    },
+  }
+}

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

@@ -0,0 +1,116 @@
+/**
+ * openlore-context-injector-helpers.ts
+ *
+ * Pure helper functions extracted from openlore-context-injector.ts so they
+ * can be exported for testing without exposing them as OpenCode Plugin symbols.
+ *
+ * OpenCode loads every export from a plugin file and tries to call it as a
+ * Plugin — exporting plain helpers directly from the plugin file causes a
+ * crash when OpenCode calls fileToSpecDomain(pluginContext) and reaches
+ * `for (const domain of domains)` with domains = undefined.
+ * This companion file is the safe export surface for unit tests.
+ */
+
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+/** Taille max d'une spec injectée en compaction (pour éviter le bloat). */
+export const MAX_SPEC_CHARS = 3000;
+
+/** Nb max de specs complètes injectées en compaction. */
+export const MAX_FULL_SPECS = 4;
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface SpecDomain {
+  name: string;
+  path: string; // chemin absolu vers spec.md
+  purpose: string; // première ligne du ## Purpose
+}
+
+// ─── loadSpecDomains ─────────────────────────────────────────────────────────
+
+/** Lit l'index des domaines OpenSpec depuis openspec/specs/. */
+export function loadSpecDomains(rootDir = process.cwd()): SpecDomain[] {
+  const specsDir = join(rootDir, 'openspec', 'specs');
+  try {
+    const dirs = readdirSync(specsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+
+    return dirs.flatMap((name) => {
+      const specPath = join(specsDir, name, 'spec.md');
+      try {
+        const content = readFileSync(specPath, 'utf-8');
+        const purposeMatch = content.match(/^## Purpose\s*\n+(.+)/m);
+        const purpose = purposeMatch
+          ? purposeMatch[1].replace(/\[PARTIAL SPEC[^\]]*\]\s*/g, '').trim()
+          : '';
+        return [{ name, path: specPath, purpose }];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+// ─── readSpec ────────────────────────────────────────────────────────────────
+
+/** Lit le contenu d'une spec, tronqué à maxChars. */
+export function readSpec(domain: SpecDomain, maxChars = MAX_SPEC_CHARS): string {
+  try {
+    const content = readFileSync(domain.path, 'utf-8');
+    if (content.length <= maxChars) return content;
+    const truncated = content.slice(0, maxChars);
+    const lastSection = truncated.lastIndexOf('\n##');
+    return (
+      (lastSection > 0 ? truncated.slice(0, lastSection) : truncated) +
+      `\n\n… (spec truncated — use get_spec ${domain.name} for full content)`
+    );
+  } catch {
+    return '';
+  }
+}
+
+// ─── fileToSpecDomain ────────────────────────────────────────────────────────
+
+/**
+ * Mappe un chemin de fichier source vers un domaine OpenSpec probable.
+ * Utilise le mapping.json si disponible, sinon heuristique par répertoire.
+ */
+export function fileToSpecDomain(
+  filePath: string,
+  domains: SpecDomain[],
+  rootDir = process.cwd()
+): string | null {
+  try {
+    const raw = readFileSync(join(rootDir, '.openlore', 'analysis', 'mapping.json'), 'utf-8');
+    const mapping = JSON.parse(raw);
+    const entries: any[] = Array.isArray(mapping) ? mapping : Object.values(mapping);
+    const match = entries.find(
+      (e: any) =>
+        e.file === filePath ||
+        e.filePath === filePath ||
+        (Array.isArray(e.files) && e.files.includes(filePath))
+    );
+    if (match?.domain || match?.spec) return match.domain ?? match.spec;
+  } catch {
+    /* mapping non disponible */
+  }
+
+  for (const domain of domains) {
+    if (filePath.toLowerCase().includes(domain.name.toLowerCase())) return domain.name;
+  }
+
+  const parts = filePath.split('/');
+  for (const part of parts) {
+    const match = domains.find((d) => d.name === part);
+    if (match) return match.name;
+  }
+
+  return null;
+}

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

@@ -0,0 +1,65 @@
+/**
+ * openlore-decision-extractor-helpers.ts
+ *
+ * Pure helper functions extracted from openlore-decision-extractor.ts so they
+ * can be exported for testing without exposing them as OpenCode Plugin symbols.
+ *
+ * OpenCode loads every export from a plugin file and tries to call it as a
+ * Plugin — exporting plain helpers directly from the plugin file causes a
+ * null-deref on S.auth at TUI bootstrap.  This companion file is the safe
+ * export surface for unit tests.
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+// ─── Thresholds ───────────────────────────────────────────────────────────────
+
+export const HUB_INDEGREE = 3; // ≥ 3 files import this file
+export const HIGH_PAGERANK = 0.4; // normalised PageRank ≥ 40 %
+export const HIGH_FILE_SCORE = 0.65; // significance score ≥ 65 %
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface FileScore {
+  inDegree: number;
+  pageRank: number;
+  fileScore: number;
+  isHub: boolean;
+}
+
+// ─── scoreFromDepGraph ────────────────────────────────────────────────────────
+
+/**
+ * Read the dep-graph and score a file by its structural centrality.
+ * Returns null if the file is not in the graph (new file — treat as unknown).
+ */
+export function scoreFromDepGraph(filePath: string, rootDir = process.cwd()): FileScore | null {
+  try {
+    const raw = readFileSync(
+      join(rootDir, '.openlore', 'analysis', 'dependency-graph.json'),
+      'utf-8'
+    );
+    const graph = JSON.parse(raw);
+    const nodes: any[] = graph.nodes ?? [];
+
+    // Match by relative path or absolute path suffix
+    const node = nodes.find(
+      (n) => n.file?.path === filePath || n.id === filePath || n.file?.path?.endsWith(filePath)
+    );
+    if (!node) return null;
+
+    const inDegree: number = node.metrics?.inDegree ?? 0;
+    const pageRank: number = node.metrics?.pageRank ?? 0;
+    const fileScore: number = node.file?.score ?? 0;
+
+    return {
+      inDegree,
+      pageRank,
+      fileScore,
+      isHub: inDegree >= HUB_INDEGREE || pageRank >= HIGH_PAGERANK || fileScore >= HIGH_FILE_SCORE,
+    };
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,211 @@
+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 {
+  loadSpecDomains,
+  readSpec,
+  fileToSpecDomain,
+} from './lib/openlore-context-injector-helpers.ts';
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const SPEC_CONTENT = `# Auth Specification
+
+> Generated by openlore
+
+## Purpose
+
+Handles authentication and session management.
+
+## Requirements
+
+### Requirement: Login
+
+The system SHALL authenticate users via JWT.
+
+#### Scenario: ValidCredentials
+- **GIVEN** valid credentials
+- **WHEN** login is called
+- **THEN** a JWT is returned
+`;
+
+async function createSpec(tmpDir: string, domain: string, content = SPEC_CONTENT) {
+  const specDir = join(tmpDir, 'openspec', 'specs', domain);
+  await mkdir(specDir, { recursive: true });
+  await writeFile(join(specDir, 'spec.md'), content);
+}
+
+// ─── loadSpecDomains ──────────────────────────────────────────────────────────
+
+describe('loadSpecDomains', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'openlore-injector-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns empty array when openspec/specs/ does not exist', () => {
+    const result = loadSpecDomains(tmpDir);
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array when openspec/specs/ has no subdirectories', async () => {
+    await mkdir(join(tmpDir, 'openspec', 'specs'), { recursive: true });
+    const result = loadSpecDomains(tmpDir);
+    expect(result).toEqual([]);
+  });
+
+  it('loads a single spec domain', async () => {
+    await createSpec(tmpDir, 'auth');
+    const result = loadSpecDomains(tmpDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('auth');
+    expect(result[0].purpose).toBe('Handles authentication and session management.');
+    expect(result[0].path).toContain('spec.md');
+  });
+
+  it('loads multiple spec domains', async () => {
+    await createSpec(tmpDir, 'auth');
+    await createSpec(tmpDir, 'api', `# Api\n\n## Purpose\n\nProvides REST endpoints.\n`);
+    const result = loadSpecDomains(tmpDir);
+    expect(result).toHaveLength(2);
+    const names = result.map((d) => d.name).sort();
+    expect(names).toEqual(['api', 'auth']);
+  });
+
+  it('skips a domain with missing spec.md', async () => {
+    await mkdir(join(tmpDir, 'openspec', 'specs', 'empty-domain'), { recursive: true });
+    await createSpec(tmpDir, 'auth');
+    const result = loadSpecDomains(tmpDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('auth');
+  });
+
+  it('extracts purpose even with [PARTIAL SPEC] prefix', async () => {
+    await createSpec(
+      tmpDir,
+      'analyzer',
+      `# Analyzer\n\n## Purpose\n\n[PARTIAL SPEC — file too large] Analyzes codebase.\n`
+    );
+    const result = loadSpecDomains(tmpDir);
+    expect(result[0].purpose).toBe('Analyzes codebase.');
+  });
+
+  it('returns empty purpose when ## Purpose section is missing', async () => {
+    await createSpec(tmpDir, 'nopurpose', `# No Purpose\n\n## Requirements\n\nSomething.\n`);
+    const result = loadSpecDomains(tmpDir);
+    expect(result[0].purpose).toBe('');
+  });
+});
+
+// ─── readSpec ─────────────────────────────────────────────────────────────────
+
+describe('readSpec', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'openlore-injector-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns empty string when spec file does not exist', () => {
+    const domain = { name: 'auth', path: join(tmpDir, 'nonexistent.md'), purpose: '' };
+    expect(readSpec(domain)).toBe('');
+  });
+
+  it('returns full content when under maxChars', async () => {
+    await createSpec(tmpDir, 'auth');
+    const [domain] = loadSpecDomains(tmpDir);
+    const result = readSpec(domain);
+    expect(result).toBe(SPEC_CONTENT);
+  });
+
+  it('truncates at a section boundary when over maxChars', async () => {
+    const longContent = SPEC_CONTENT + '\n## Section2\n\n' + 'x'.repeat(5000);
+    await createSpec(tmpDir, 'auth', longContent);
+    const [domain] = loadSpecDomains(tmpDir);
+    const result = readSpec(domain, 200);
+    expect(result).toContain('spec truncated');
+    expect(result.length).toBeLessThan(longContent.length);
+  });
+
+  it('truncates without section boundary when content has no ## headers after truncation point', async () => {
+    const flatContent = 'a'.repeat(500);
+    await createSpec(tmpDir, 'auth', flatContent);
+    const [domain] = loadSpecDomains(tmpDir);
+    const result = readSpec(domain, 100);
+    expect(result).toContain('spec truncated');
+  });
+});
+
+// ─── fileToSpecDomain ─────────────────────────────────────────────────────────
+
+describe('fileToSpecDomain', () => {
+  let tmpDir: string;
+  const domains = [
+    { name: 'auth', path: '', purpose: '' },
+    { name: 'api', path: '', purpose: '' },
+    { name: 'analyzer', path: '', purpose: '' },
+  ];
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'openlore-injector-test-'));
+    await mkdir(join(tmpDir, '.openlore', 'analysis'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns null when no match is found', () => {
+    const result = fileToSpecDomain('src/unknown/mystery.ts', domains, tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('matches by domain name in file path (heuristic)', () => {
+    const result = fileToSpecDomain('src/auth/middleware.ts', domains, tmpDir);
+    expect(result).toBe('auth');
+  });
+
+  it('matches by parent directory name', () => {
+    const result = fileToSpecDomain('src/api/routes.ts', domains, tmpDir);
+    expect(result).toBe('api');
+  });
+
+  it('uses mapping.json when available (array form)', async () => {
+    const mapping = [{ file: 'src/core/analyzer/engine.ts', domain: 'analyzer' }];
+    await writeFile(join(tmpDir, '.openlore', 'analysis', 'mapping.json'), JSON.stringify(mapping));
+    const result = fileToSpecDomain('src/core/analyzer/engine.ts', domains, tmpDir);
+    expect(result).toBe('analyzer');
+  });
+
+  it('uses mapping.json when available (object form)', async () => {
+    const mapping = {
+      'req-1': { filePath: 'src/api/server.ts', spec: 'api' },
+    };
+    await writeFile(join(tmpDir, '.openlore', 'analysis', 'mapping.json'), JSON.stringify(mapping));
+    const result = fileToSpecDomain('src/api/server.ts', domains, tmpDir);
+    expect(result).toBe('api');
+  });
+
+  it('falls back to heuristic when mapping.json has no match', async () => {
+    const mapping = [{ file: 'src/other.ts', domain: 'api' }];
+    await writeFile(join(tmpDir, '.openlore', 'analysis', 'mapping.json'), JSON.stringify(mapping));
+    const result = fileToSpecDomain('src/auth/service.ts', domains, tmpDir);
+    expect(result).toBe('auth');
+  });
+
+  it('handles malformed mapping.json without throwing', async () => {
+    await writeFile(join(tmpDir, '.openlore', 'analysis', 'mapping.json'), 'not valid json');
+    const result = fileToSpecDomain('src/auth/service.ts', domains, tmpDir);
+    expect(result).toBe('auth');
+  });
+});