@wooojin/forgen 0.1.0

package/dist/engine/compound-cli.js

@@ -0,0 +1,250 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { extractTags, parseFrontmatterOnly, parseSolutionV3 } from './solution-format.js';
+import { mutateSolutionFile } from './solution-writer.js';
+import { ME_SOLUTIONS, ME_RULES } from '../core/paths.js';
+/** Scan saved compound entries and return summaries */
+function scanEntries() {
+    const summaries = [];
+    const dirs = [
+        { dir: ME_SOLUTIONS, category: 'solution' },
+        { dir: ME_RULES, category: 'rule' },
+    ];
+    for (const { dir, category } of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const fm = parseFrontmatterOnly(content);
+                if (!fm)
+                    continue;
+                summaries.push({
+                    name: fm.name,
+                    status: fm.status,
+                    confidence: fm.confidence,
+                    type: fm.type,
+                    category,
+                    tags: fm.tags,
+                    evidence: fm.evidence,
+                    created: fm.created,
+                    filePath,
+                });
+            }
+        }
+        catch { /* 개별 솔루션 파일 파싱 실패 무시 — 손상된 파일은 건너뛰기 */ }
+    }
+    return summaries;
+}
+/** Status icon */
+function statusIcon(status) {
+    switch (status) {
+        case 'mature': return 'M';
+        case 'verified': return 'V';
+        case 'candidate': return 'C';
+        case 'experiment': return 'E';
+        case 'retired': return 'R';
+        default: return '?';
+    }
+}
+/** List all solutions with status summary */
+export function listSolutions() {
+    const entries = scanEntries();
+    if (entries.length === 0) {
+        console.log('\n  No compound entries found.\n');
+        return;
+    }
+    // Group by status
+    const groups = {};
+    for (const entry of entries) {
+        if (!groups[entry.status])
+            groups[entry.status] = [];
+        groups[entry.status].push(entry);
+    }
+    const order = ['mature', 'verified', 'candidate', 'experiment', 'retired'];
+    console.log('\n  Compound Entries\n');
+    let total = 0;
+    for (const status of order) {
+        const group = groups[status];
+        if (!group || group.length === 0)
+            continue;
+        total += group.length;
+        console.log(`  [${statusIcon(status)}] ${status} (${group.length})`);
+        for (const entry of group) {
+            const ev = entry.evidence;
+            const evStr = `inj:${ev.injected} ref:${ev.reflected} neg:${ev.negative}`;
+            console.log(`      ${entry.name} [${entry.category}]  (${entry.confidence.toFixed(2)})  ${evStr}  [${entry.tags.slice(0, 3).join(', ')}]`);
+        }
+    }
+    console.log(`\n  Total: ${total} entries\n`);
+}
+/** Inspect a single saved entry in detail */
+export function inspectSolution(name) {
+    const entries = scanEntries();
+    const entry = entries.find(s => s.name === name);
+    if (!entry) {
+        console.log(`\n  Entry "${name}" not found.\n`);
+        return;
+    }
+    // Read full content
+    const content = fs.readFileSync(entry.filePath, 'utf-8');
+    const full = parseSolutionV3(content);
+    console.log(`\n  Entry: ${entry.name}`);
+    console.log(`  Category: ${entry.category}`);
+    console.log(`  Status: ${entry.status} (confidence: ${entry.confidence.toFixed(2)})`);
+    console.log(`  Type: ${entry.type}`);
+    console.log(`  Tags: [${entry.tags.join(', ')}]`);
+    console.log(`  Created: ${entry.created}`);
+    console.log(`  Evidence:`);
+    console.log(`    injected: ${entry.evidence.injected}`);
+    console.log(`    reflected: ${entry.evidence.reflected}`);
+    console.log(`    negative: ${entry.evidence.negative}`);
+    console.log(`    sessions: ${entry.evidence.sessions}`);
+    console.log(`    reExtracted: ${entry.evidence.reExtracted}`);
+    if (full) {
+        if (full.context)
+            console.log(`\n  Context: ${full.context}`);
+        if (full.content)
+            console.log(`\n  Content:\n    ${full.content.split('\n').join('\n    ')}`);
+    }
+    console.log(`\n  File: ${entry.filePath}\n`);
+}
+/** Remove a saved entry by name */
+export function removeSolution(name) {
+    const entries = scanEntries();
+    const entry = entries.find(s => s.name === name);
+    if (!entry) {
+        console.log(`\n  Entry "${name}" not found.\n`);
+        return;
+    }
+    try {
+        fs.unlinkSync(entry.filePath);
+        console.log(`\n  Removed: ${name} [${entry.category}] (${entry.filePath})\n`);
+    }
+    catch (e) {
+        console.log(`\n  Failed to remove: ${e.message}\n`);
+    }
+}
+/**
+ * Names of extractors that have been removed from the compound pipeline.
+ * Any solution file on disk whose `name` matches one of these entries is
+ * an artifact of a removed extractor and should be retired.
+ *
+ * Current list (added by C4 cleanup, 2026-04-09):
+ *   - `recurring-task-pattern`: word-frequency histogram, not a real
+ *     pattern. Observed injected 105+ times in production.
+ *   - `modification-hotspot`: directory modification count with generic
+ *     "maybe refactor this" advice.
+ *
+ * Add future entries here whenever an extractor is removed from
+ * `compound-extractor.ts` so users can clean up their stores.
+ */
+const STALE_EXTRACTOR_NAMES = [
+    'recurring-task-pattern',
+    'modification-hotspot',
+];
+/**
+ * Retire solutions whose names match extractors that have been removed
+ * from the compound pipeline. Retired solutions are excluded from the
+ * index (see `solution-index.ts:142`) so they stop being surfaced in
+ * MCP search and hook injection, but the file stays on disk for
+ * audit / undo purposes.
+ *
+ * M-3 (2026-04-09): the C4 extractor cleanup left orphaned files in
+ * users' `~/.forgen/me/solutions/` directories. Without this migration,
+ * files like `recurring-task-pattern.md` (which had injected=113 on
+ * the author's own machine at fix time) continue to pollute matching
+ * results until the user manually deletes them.
+ */
+export function cleanStaleSolutions() {
+    const entries = scanEntries().filter(e => e.category === 'solution');
+    const stale = entries.filter(e => STALE_EXTRACTOR_NAMES.includes(e.name));
+    if (stale.length === 0) {
+        console.log('\n  No stale extractor artifacts found.\n');
+        return;
+    }
+    console.log(`\n  Found ${stale.length} stale extractor artifact(s):`);
+    for (const entry of stale) {
+        console.log(`    - ${entry.name} (status: ${entry.status}, injected: ${entry.evidence.injected})`);
+    }
+    console.log();
+    let retired = 0;
+    for (const entry of stale) {
+        // Skip already-retired files — idempotent.
+        if (entry.status === 'retired') {
+            console.log(`    ✓ ${entry.name} already retired, skipping`);
+            continue;
+        }
+        const ok = mutateSolutionFile(entry.filePath, sol => {
+            sol.frontmatter.status = 'retired';
+            sol.frontmatter.updated = new Date().toISOString().split('T')[0];
+            return true;
+        });
+        if (ok) {
+            retired++;
+            console.log(`    ✗ ${entry.name} retired`);
+        }
+        else {
+            console.log(`    ! ${entry.name} failed to update`);
+        }
+    }
+    console.log(`\n  Retired ${retired}/${stale.length} stale artifact(s).\n`);
+    console.log('  Tip: retired files are excluded from index + MCP search but');
+    console.log('  remain on disk. Use `forgen compound remove <name>` to delete.\n');
+}
+/** Retag all solutions using improved extractTags */
+export function retagSolutions() {
+    const entries = scanEntries().filter(e => e.category === 'solution');
+    if (entries.length === 0) {
+        console.log('\n  No solutions to retag.\n');
+        return;
+    }
+    // PR2b: solution-writer.mutateSolutionFile로 통합. lock + fresh re-read.
+    // 동시 hook이 같은 .md를 update해도 retag 결과가 손실되지 않는다.
+    let retagged = 0;
+    for (const entry of entries) {
+        const ok = mutateSolutionFile(entry.filePath, sol => {
+            const source = [sol.context, sol.content].filter(Boolean).join(' ');
+            const newTags = extractTags(source);
+            sol.frontmatter.tags = newTags;
+            return true;
+        });
+        if (ok)
+            retagged++;
+        else
+            console.log(`    Failed: ${entry.name}`);
+    }
+    console.log(`\n  Retagged ${retagged}/${entries.length} solutions.\n`);
+}
+/** Rollback auto-extracted solutions since a given date */
+export function rollbackSolutions(sinceDate) {
+    const since = new Date(sinceDate);
+    if (Number.isNaN(since.getTime())) {
+        console.log(`\n  Invalid date: ${sinceDate}\n`);
+        return;
+    }
+    const solutions = scanEntries().filter((entry) => entry.category === 'solution');
+    const toRemove = solutions.filter((solution) => {
+        if (solution.evidence.reflected > 0 || solution.evidence.sessions > 0)
+            return false; // keep used ones
+        const created = new Date(solution.created);
+        return created >= since;
+    });
+    if (toRemove.length === 0) {
+        console.log(`\n  No solutions to rollback since ${sinceDate}.\n`);
+        return;
+    }
+    console.log(`\n  Rolling back ${toRemove.length} solutions since ${sinceDate}:\n`);
+    for (const sol of toRemove) {
+        try {
+            fs.unlinkSync(sol.filePath);
+            console.log(`    Removed: ${sol.name}`);
+        }
+        catch {
+            console.log(`    Failed: ${sol.name}`);
+        }
+    }
+    console.log();
+}

package/dist/engine/compound-extractor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Forgen — Compound Knowledge Extractor
+ *
+ * Extracts reusable patterns and decisions from git history and session context.
+ * Runs quality gates (structure, toxicity, trivial, dedup) before persisting solutions.
+ *
+ * Module Structure:
+ * - Lines 1-50: Imports, constants, SHA validation, LastExtraction/ExtractedSolution interfaces
+ * - Lines 50-115: Git helpers — getNewCommits, getCommitMessages, getGitDiff, getDiffStats
+ * - Lines 115-190: Quality Gates — gate0 (worth extracting), gate1 (structure), gate2 (toxicity),
+ *     gateTrivial (trivial rejection), gate3 (dedup)
+ * - Lines 190-275: extractFromDiff — pattern extraction from git diff (modules, errors, imports, commits)
+ * - Lines 275-395: extractFromSessionContext — prompt/write history analysis (actions, hotspots, tech)
+ * - Lines 396-475: saveExtractedSolution, updateReExtractedCounter — solution persistence
+ * - Lines 477-555: runExtraction — main entry point orchestrating gates + extraction + state
+ * - Lines 557-634: processExtractionResults, isExtractionPaused, pauseExtraction, resumeExtraction
+ */
+import type { SolutionType } from './solution-format.js';
+interface ExtractedSolution {
+    name: string;
+    type: SolutionType;
+    tags: string[];
+    identifiers: string[];
+    context: string;
+    content: string;
+}
+interface WriteContextEntry {
+    filePath: string;
+    contentSnippet: string;
+    fileExtension: string;
+}
+/**
+ * Load Claude session prompts + writes correlated to `cwd`.
+ *
+ * Exported primarily for test assertions (the `claude-session-context`
+ * tests need to verify that correlation picks the right project's
+ * sessions and ignores unrelated ones). Before C4 the tests could
+ * observe this indirectly via the now-removed `recurring-task-pattern`
+ * extractor; now they check this loader directly. Not intended for
+ * production callers outside the extractor pipeline.
+ */
+export declare function loadClaudeProjectSessionContext(cwd: string, lastExtractedAt: string): {
+    prompts: string[];
+    writes: WriteContextEntry[];
+};
+export declare function previewExtraction(cwd: string): Promise<{
+    preview: ExtractedSolution[];
+    skipped: string[];
+    reason?: string;
+}>;
+/** Main extraction function — called from SessionStart or CLI */
+export declare function runExtraction(cwd: string, sessionId: string): Promise<{
+    extracted: string[];
+    skipped: string[];
+    reason?: string;
+}>;
+/** Process LLM extraction results (called after LLM returns) */
+export declare function processExtractionResults(rawJson: string, sessionId: string): {
+    saved: string[];
+    skipped: string[];
+};
+/** Check if extraction is paused */
+export declare function isExtractionPaused(): boolean;
+/** Pause auto-extraction */
+export declare function pauseExtraction(): void;
+/** Resume auto-extraction */
+export declare function resumeExtraction(): void;
+export {};