@syntesseraai/opencode-feature-factory 0.2.45 → 0.3.0

package/dist/local-recall/processed-log.js

@@ -0,0 +1,82 @@
+/**
+ * Processed Log
+ *
+ * Tracks which messages have already been processed for memory extraction.
+ * Uses content-hash based idempotency: each processed entry stores a
+ * hash derived from the message content so re-extractions with identical
+ * content are skipped even if message IDs change.
+ *
+ * Stored as a JSON file at .feature-factory/local-recall/processed.json
+ */
+import { createHash } from 'node:crypto';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+function getLogPath(directory) {
+    return join(directory, '.feature-factory', 'local-recall', 'processed.json');
+}
+// ────────────────────────────────────────────────────────────
+// Content hashing
+// ────────────────────────────────────────────────────────────
+/**
+ * Create a SHA-256 content hash from one or more text fragments.
+ * Used to de-duplicate extraction across re-processes / message edits.
+ */
+export function contentHash(...fragments) {
+    const h = createHash('sha256');
+    for (const f of fragments) {
+        h.update(f);
+    }
+    return h.digest('hex');
+}
+// ────────────────────────────────────────────────────────────
+// Log CRUD
+// ────────────────────────────────────────────────────────────
+/**
+ * Read all processed entries from the log.
+ */
+export async function readProcessedLog(directory) {
+    try {
+        const raw = await readFile(getLogPath(directory), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a specific message has already been processed (by message ID).
+ */
+export async function isProcessed(directory, messageID) {
+    const log = await readProcessedLog(directory);
+    return log.some((entry) => entry.messageID === messageID);
+}
+/**
+ * Check if a content hash has already been processed.
+ * This catches duplicate content even if message IDs differ.
+ */
+export async function isContentProcessed(directory, hash) {
+    const log = await readProcessedLog(directory);
+    return log.some((entry) => entry.contentHash === hash);
+}
+/**
+ * Mark messages as processed by appending entries to the log.
+ */
+export async function markProcessed(directory, entries) {
+    const logPath = getLogPath(directory);
+    await mkdir(dirname(logPath), { recursive: true });
+    const existing = await readProcessedLog(directory);
+    const merged = [...existing, ...entries];
+    await writeFile(logPath, JSON.stringify(merged, null, 2), 'utf-8');
+}
+/**
+ * Get the set of already-processed message IDs for fast lookup.
+ */
+export function getProcessedMessageIDs(log) {
+    return new Set(log.map((e) => e.messageID));
+}
+/**
+ * Get the set of already-processed content hashes for fast lookup.
+ */
+export function getProcessedHashes(log) {
+    return new Set(log.map((e) => e.contentHash));
+}

package/dist/local-recall/session-extractor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * session-extractor.ts — Extracts learnings from OpenCode session messages.
+ *
+ * Scans assistant text parts for reusable knowledge (patterns, decisions,
+ * debugging insights, preferences, context, procedures) and returns
+ * ExtractionResult[] ready for storage.
+ */
+import type { ExtractionInput, ExtractionResult, OCPart } from './types.js';
+/**
+ * Extract learnings from a set of text parts for a single message.
+ *
+ * Each qualifying text part that passes heuristic classification
+ * becomes one ExtractionResult.
+ */
+export declare function extractFromParts(input: ExtractionInput, parts: OCPart[]): ExtractionResult[];
+/**
+ * High-level: extract from a message by reading its parts from storage.
+ */
+export declare function extractFromMessage(input: ExtractionInput): Promise<ExtractionResult[]>;

package/dist/local-recall/session-extractor.js

@@ -0,0 +1,172 @@
+/**
+ * session-extractor.ts — Extracts learnings from OpenCode session messages.
+ *
+ * Scans assistant text parts for reusable knowledge (patterns, decisions,
+ * debugging insights, preferences, context, procedures) and returns
+ * ExtractionResult[] ready for storage.
+ */
+import { listParts } from './storage-reader.js';
+const CATEGORY_RULES = [
+    {
+        category: 'pattern',
+        weight: 0.9,
+        patterns: [
+            /\bpattern\b/i,
+            /\bbest practice\b/i,
+            /\bidiom(atic)?\b/i,
+            /\bconvention\b/i,
+            /\balways use\b/i,
+            /\bprefer\s+\w+\s+over\b/i,
+        ],
+    },
+    {
+        category: 'decision',
+        weight: 0.85,
+        patterns: [
+            /\bdecid(e|ed|ing)\b/i,
+            /\bchose\b/i,
+            /\btrade-?off\b/i,
+            /\bwent with\b/i,
+            /\binstead of\b/i,
+            /\bwe (should|chose|picked)\b/i,
+        ],
+    },
+    {
+        category: 'debugging',
+        weight: 0.8,
+        patterns: [
+            /\bbug\b/i,
+            /\bfix(ed|ing)?\b/i,
+            /\berror\b/i,
+            /\broot cause\b/i,
+            /\bwork-?around\b/i,
+            /\bregression\b/i,
+            /\bstack trace\b/i,
+        ],
+    },
+    {
+        category: 'preference',
+        weight: 0.7,
+        patterns: [
+            /\bprefer(ence|red|s)?\b/i,
+            /\bstyle\b/i,
+            /\bdon't like\b/i,
+            /\bfavor\b/i,
+            /\brather\b/i,
+        ],
+    },
+    {
+        category: 'procedure',
+        weight: 0.75,
+        patterns: [
+            /\bstep[- ]?by[- ]?step\b/i,
+            /\bworkflow\b/i,
+            /\bprocedure\b/i,
+            /\bhow to\b/i,
+            /\brecipe\b/i,
+            /\brun(ning)?\s+(the|this)?\s*command\b/i,
+        ],
+    },
+    {
+        category: 'context',
+        weight: 0.6,
+        patterns: [
+            /\barchitecture\b/i,
+            /\bdesign\b/i,
+            /\bconstraint\b/i,
+            /\brequirement\b/i,
+            /\binfrastructure\b/i,
+            /\bstack\b/i,
+        ],
+    },
+];
+// ────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────
+/** Score text against category rules and return best match (if any). */
+function classifyText(text) {
+    let best = null;
+    for (const rule of CATEGORY_RULES) {
+        let hits = 0;
+        for (const pat of rule.patterns) {
+            if (pat.test(text))
+                hits++;
+        }
+        if (hits === 0)
+            continue;
+        const confidence = Math.min(1, (hits / rule.patterns.length) * rule.weight);
+        if (!best || confidence > best.confidence) {
+            best = { category: rule.category, confidence };
+        }
+    }
+    return best;
+}
+/** Derive a short title from the first meaningful sentence. */
+function deriveTitle(text) {
+    const firstLine = text.split(/\n/).find((l) => l.trim().length > 10) ?? text;
+    const trimmed = firstLine.replace(/^#+\s*/, '').trim();
+    return trimmed.length > 120 ? trimmed.slice(0, 117) + '...' : trimmed;
+}
+/** Extract simple tags from text. */
+function deriveTags(text) {
+    const tags = new Set();
+    // Language mentions
+    const langs = text.match(/\b(TypeScript|JavaScript|Python|Rust|Go|Java|C\+\+|Ruby|Swift|Kotlin)\b/gi);
+    if (langs)
+        langs.forEach((l) => tags.add(l.toLowerCase()));
+    // Framework mentions
+    const frameworks = text.match(/\b(React|Next\.?js|Vue|Angular|Express|Django|Flask|Spring|Rails)\b/gi);
+    if (frameworks)
+        frameworks.forEach((f) => tags.add(f.toLowerCase()));
+    // Tool mentions
+    const tools = text.match(/\b(Docker|Kubernetes|Terraform|AWS|GCP|Azure|GitHub|GitLab)\b/gi);
+    if (tools)
+        tools.forEach((t) => tags.add(t.toLowerCase()));
+    return [...tags].slice(0, 10);
+}
+// ────────────────────────────────────────────────────────────
+// Minimum thresholds
+// ────────────────────────────────────────────────────────────
+/** Minimum text length to consider for extraction. */
+const MIN_TEXT_LENGTH = 80;
+/** Minimum confidence to accept a classification. */
+const MIN_CONFIDENCE = 0.15;
+// ────────────────────────────────────────────────────────────
+// Public API
+// ────────────────────────────────────────────────────────────
+/**
+ * Extract learnings from a set of text parts for a single message.
+ *
+ * Each qualifying text part that passes heuristic classification
+ * becomes one ExtractionResult.
+ */
+export function extractFromParts(input, parts) {
+    const results = [];
+    for (const part of parts) {
+        if (part.type !== 'text' || !part.text)
+            continue;
+        if (part.text.length < MIN_TEXT_LENGTH)
+            continue;
+        const classification = classifyText(part.text);
+        if (!classification || classification.confidence < MIN_CONFIDENCE)
+            continue;
+        results.push({
+            sessionID: input.sessionID,
+            messageID: input.messageID,
+            category: classification.category,
+            title: deriveTitle(part.text),
+            body: part.text,
+            tags: deriveTags(part.text),
+            importance: classification.confidence,
+            source: 'session',
+        });
+    }
+    return results;
+}
+/**
+ * High-level: extract from a message by reading its parts from storage.
+ */
+export async function extractFromMessage(input) {
+    const parts = await listParts(input.messageID);
+    return extractFromParts(input, parts);
+}

package/dist/local-recall/storage-reader.d.ts

@@ -0,0 +1,40 @@
+/**
+ * OpenCode Storage Readers
+ *
+ * Reads OpenCode's native JSON storage from ~/.local/share/opencode/storage/
+ * with adapters for project, session, message, and part entities.
+ */
+import type { OCProject, OCSession, OCMessage, OCPart } from './types.js';
+/**
+ * Find the project record whose worktree matches `directory`.
+ * The project hash is a SHA-1 of the worktree path.
+ */
+export declare function findProject(directory: string): Promise<OCProject | null>;
+/**
+ * List all known projects.
+ */
+export declare function listProjects(): Promise<OCProject[]>;
+/**
+ * List sessions for a given project hash.
+ */
+export declare function listSessions(projectID: string): Promise<OCSession[]>;
+/**
+ * Get a single session by its ID within a project.
+ */
+export declare function getSession(projectID: string, sessionID: string): Promise<OCSession | null>;
+/**
+ * List all messages in a session, sorted by creation time.
+ */
+export declare function listMessages(sessionID: string): Promise<OCMessage[]>;
+/**
+ * Get a single message by ID.
+ */
+export declare function getMessage(sessionID: string, messageID: string): Promise<OCMessage | null>;
+/**
+ * List all parts for a given message, sorted by start time.
+ */
+export declare function listParts(messageID: string): Promise<OCPart[]>;
+/**
+ * Get a single part by ID.
+ */
+export declare function getPart(messageID: string, partID: string): Promise<OCPart | null>;

package/dist/local-recall/storage-reader.js

@@ -0,0 +1,147 @@
+/**
+ * OpenCode Storage Readers
+ *
+ * Reads OpenCode's native JSON storage from ~/.local/share/opencode/storage/
+ * with adapters for project, session, message, and part entities.
+ */
+import { readFile, readdir, stat, realpath } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+// ── Storage base path ───────────────────────────────────────────
+function getStorageBase() {
+    return join(homedir(), '.local', 'share', 'opencode', 'storage');
+}
+// ── Helpers ─────────────────────────────────────────────────────
+async function readJsonFile(filePath) {
+    const raw = await readFile(filePath, 'utf-8');
+    return JSON.parse(raw);
+}
+async function readAllJsonInDir(dirPath) {
+    try {
+        const entries = await readdir(dirPath);
+        const jsonFiles = entries.filter((e) => e.endsWith('.json'));
+        const results = [];
+        for (const file of jsonFiles) {
+            try {
+                const data = await readJsonFile(join(dirPath, file));
+                results.push(data);
+            }
+            catch {
+                // Skip malformed files
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+async function dirExists(dirPath) {
+    try {
+        const s = await stat(dirPath);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+// ── Project Reader ──────────────────────────────────────────────
+/**
+ * Find the project record whose worktree matches `directory`.
+ * The project hash is a SHA-1 of the worktree path.
+ */
+export async function findProject(directory) {
+    const projectDir = join(getStorageBase(), 'project');
+    const projects = await readAllJsonInDir(projectDir);
+    // Normalise both sides so symlinks / trailing slashes don't cause mismatches
+    let normalisedInput;
+    try {
+        normalisedInput = await realpath(directory);
+    }
+    catch {
+        normalisedInput = directory; // fallback when directory doesn't exist yet
+    }
+    for (const p of projects) {
+        let normalisedWorktree;
+        try {
+            normalisedWorktree = await realpath(p.worktree);
+        }
+        catch {
+            normalisedWorktree = p.worktree;
+        }
+        if (normalisedWorktree === normalisedInput || p.worktree === directory) {
+            return p;
+        }
+    }
+    return null;
+}
+/**
+ * List all known projects.
+ */
+export async function listProjects() {
+    return readAllJsonInDir(join(getStorageBase(), 'project'));
+}
+// ── Session Reader ──────────────────────────────────────────────
+/**
+ * List sessions for a given project hash.
+ */
+export async function listSessions(projectID) {
+    const sessionDir = join(getStorageBase(), 'session', projectID);
+    return readAllJsonInDir(sessionDir);
+}
+/**
+ * Get a single session by its ID within a project.
+ */
+export async function getSession(projectID, sessionID) {
+    const sessionDir = join(getStorageBase(), 'session', projectID);
+    try {
+        return await readJsonFile(join(sessionDir, `${sessionID}.json`));
+    }
+    catch {
+        return null;
+    }
+}
+// ── Message Reader ──────────────────────────────────────────────
+/**
+ * List all messages in a session, sorted by creation time.
+ */
+export async function listMessages(sessionID) {
+    const msgDir = join(getStorageBase(), 'message', sessionID);
+    const messages = await readAllJsonInDir(msgDir);
+    return messages.sort((a, b) => a.time.created - b.time.created);
+}
+/**
+ * Get a single message by ID.
+ */
+export async function getMessage(sessionID, messageID) {
+    const msgDir = join(getStorageBase(), 'message', sessionID);
+    try {
+        return await readJsonFile(join(msgDir, `${messageID}.json`));
+    }
+    catch {
+        return null;
+    }
+}
+// ── Part Reader ─────────────────────────────────────────────────
+/**
+ * List all parts for a given message, sorted by start time.
+ */
+export async function listParts(messageID) {
+    const partDir = join(getStorageBase(), 'part', messageID);
+    if (!(await dirExists(partDir)))
+        return [];
+    const parts = await readAllJsonInDir(partDir);
+    return parts.sort((a, b) => a.time.start - b.time.start);
+}
+/**
+ * Get a single part by ID.
+ */
+export async function getPart(messageID, partID) {
+    const partDir = join(getStorageBase(), 'part', messageID);
+    try {
+        return await readJsonFile(join(partDir, `${partID}.json`));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/local-recall/thinking-extractor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * thinking-extractor.ts — Extracts learnings from "thinking" / reasoning blocks.
+ *
+ * OpenCode stores extended-thinking or chain-of-thought content in parts
+ * with type "reasoning". These often contain high-signal insights about
+ * decision making and problem solving that are worth capturing.
+ */
+import type { ExtractionInput, ExtractionResult, OCPart } from './types.js';
+/**
+ * Extract learnings specifically from reasoning / thinking parts.
+ */
+export declare function extractFromThinkingParts(input: ExtractionInput, parts: OCPart[]): ExtractionResult[];
+/**
+ * High-level: extract thinking-based learnings from a message.
+ */
+export declare function extractThinkingFromMessage(input: ExtractionInput): Promise<ExtractionResult[]>;

package/dist/local-recall/thinking-extractor.js

@@ -0,0 +1,132 @@
+/**
+ * thinking-extractor.ts — Extracts learnings from "thinking" / reasoning blocks.
+ *
+ * OpenCode stores extended-thinking or chain-of-thought content in parts
+ * with type "reasoning". These often contain high-signal insights about
+ * decision making and problem solving that are worth capturing.
+ */
+import { listParts } from './storage-reader.js';
+const THINKING_SIGNALS = [
+    {
+        category: 'decision',
+        weight: 0.9,
+        patterns: [
+            /\blet me think about\b/i,
+            /\bthe (better|right|correct) approach\b/i,
+            /\bI('ll| will) go with\b/i,
+            /\bweighing (the )?(options|trade-?offs)\b/i,
+            /\boption [A-D1-4] (is|seems|looks)\b/i,
+            /\bpros and cons\b/i,
+        ],
+    },
+    {
+        category: 'debugging',
+        weight: 0.85,
+        patterns: [
+            /\bthe (issue|problem|bug) (is|was|seems)\b/i,
+            /\broot cause\b/i,
+            /\bthis (fails|breaks|errors) because\b/i,
+            /\bI (notice|see|found) (that |the )?(error|issue|bug)\b/i,
+            /\bstack trace (shows|indicates|reveals)\b/i,
+        ],
+    },
+    {
+        category: 'pattern',
+        weight: 0.8,
+        patterns: [
+            /\bthe (standard|common|typical) (pattern|approach|way)\b/i,
+            /\bbest practice\b/i,
+            /\bfollow(ing)? the (same |existing )?(pattern|convention)\b/i,
+            /\bthis is (a |the )?(standard|idiomatic)\b/i,
+        ],
+    },
+    {
+        category: 'context',
+        weight: 0.7,
+        patterns: [
+            /\blooking at the (code|codebase|architecture|structure)\b/i,
+            /\bthe (project|repo|codebase) (uses|follows|has)\b/i,
+            /\bbased on (the |my )?understanding\b/i,
+            /\bthe (current|existing) (setup|config|architecture)\b/i,
+        ],
+    },
+    {
+        category: 'procedure',
+        weight: 0.75,
+        patterns: [
+            /\bfirst[\s\S]+then[\s\S]+finally\b/i,
+            /\bstep \d/i,
+            /\bthe (process|procedure|workflow) (is|involves)\b/i,
+            /\bI need to:?\s*\n/i,
+        ],
+    },
+];
+// ────────────────────────────────────────────────────────────
+// Analysis
+// ────────────────────────────────────────────────────────────
+const MIN_THINKING_LENGTH = 120;
+const MIN_THINKING_CONFIDENCE = 0.2;
+function classifyThinking(text) {
+    let best = null;
+    for (const signal of THINKING_SIGNALS) {
+        let hits = 0;
+        for (const pat of signal.patterns) {
+            if (pat.test(text))
+                hits++;
+        }
+        if (hits === 0)
+            continue;
+        const confidence = Math.min(1, (hits / signal.patterns.length) * signal.weight);
+        if (!best || confidence > best.confidence) {
+            best = { category: signal.category, confidence };
+        }
+    }
+    return best;
+}
+function deriveThinkingTitle(text) {
+    // Attempt to find a summary-like sentence
+    const sentences = text.split(/[.!?]\s+/).filter((s) => s.trim().length > 15);
+    const summary = sentences.find((s) => /\b(so|therefore|conclusion|result|decided|approach)\b/i.test(s)) ??
+        sentences[0];
+    if (!summary)
+        return 'Thinking insight';
+    const clean = summary.replace(/^[\s*#-]+/, '').trim();
+    return clean.length > 120 ? clean.slice(0, 117) + '...' : clean;
+}
+// ────────────────────────────────────────────────────────────
+// Public API
+// ────────────────────────────────────────────────────────────
+/**
+ * Extract learnings specifically from reasoning / thinking parts.
+ */
+export function extractFromThinkingParts(input, parts) {
+    const results = [];
+    for (const part of parts) {
+        // Accept "reasoning" type parts (extended thinking)
+        if (part.type !== 'reasoning' || !part.text)
+            continue;
+        if (part.text.length < MIN_THINKING_LENGTH)
+            continue;
+        const classification = classifyThinking(part.text);
+        if (!classification || classification.confidence < MIN_THINKING_CONFIDENCE)
+            continue;
+        results.push({
+            sessionID: input.sessionID,
+            messageID: input.messageID,
+            category: classification.category,
+            title: deriveThinkingTitle(part.text),
+            body: part.text,
+            tags: ['thinking', 'reasoning'],
+            importance: Math.min(1, classification.confidence * 1.1), // slight boost for thinking
+            source: 'thinking',
+        });
+    }
+    return results;
+}
+/**
+ * High-level: extract thinking-based learnings from a message.
+ */
+export async function extractThinkingFromMessage(input) {
+    const parts = await listParts(input.messageID);
+    return extractFromThinkingParts(input, parts);
+}