@wooojin/forgen 0.4.9 → 0.4.11

package/dist/engine/extraction-diff.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pattern extraction from git diff.
+ *
+ * Extracted from compound-extractor.ts — heuristic extraction of reusable
+ * patterns from git diff content without LLM involvement.
+ */
+import type { ExtractedSolution } from './extraction-gates.js';
+/** Find common prefix among an array of strings */
+export declare function findCommonPrefix(strings: string[]): string;
+/** Simple local extraction from git diff (no LLM needed) */
+export declare function extractFromDiff(gitLog: string, gitDiff: string): ExtractedSolution[];

package/dist/engine/extraction-diff.js

@@ -0,0 +1,105 @@
+/**
+ * Pattern extraction from git diff.
+ *
+ * Extracted from compound-extractor.ts — heuristic extraction of reusable
+ * patterns from git diff content without LLM involvement.
+ */
+import * as path from 'node:path';
+import { extractTags } from './solution-format.js';
+/** Find common prefix among an array of strings */
+export function findCommonPrefix(strings) {
+    if (strings.length === 0)
+        return '';
+    let prefix = strings[0];
+    for (const s of strings.slice(1)) {
+        while (!s.startsWith(prefix) && prefix.length > 0) {
+            prefix = prefix.slice(0, -1);
+        }
+    }
+    return prefix.replace(/-$/, '');
+}
+/** Simple local extraction from git diff (no LLM needed) */
+export function extractFromDiff(gitLog, gitDiff) {
+    const solutions = [];
+    // 1. Detect new files/modules created
+    const newFiles = gitDiff.match(/^\+\+\+ b\/(.+)$/gm);
+    if (newFiles && newFiles.length >= 2) {
+        const fileNames = newFiles.map(f => f.replace('+++ b/', ''));
+        const ext = path.extname(fileNames[0]);
+        const dir = path.dirname(fileNames[0]).split('/').pop() ?? '';
+        if (ext && dir) {
+            const basenames = fileNames.map(f => path.basename(f, ext));
+            const commonPrefix = findCommonPrefix(basenames);
+            if (commonPrefix.length >= 3) {
+                solutions.push({
+                    name: `module-${commonPrefix}-pattern`,
+                    type: 'pattern',
+                    tags: extractTags(`${fileNames.join(' ')} ${dir}`),
+                    identifiers: basenames.filter(b => b.length >= 4).slice(0, 5),
+                    context: `File organization pattern in ${dir}/`,
+                    content: `Files follow the naming pattern: ${commonPrefix}*${ext} in ${dir}/`,
+                });
+            }
+        }
+    }
+    // 2. Detect error handling patterns from diff
+    const errorPatterns = gitDiff.match(/^\+.*(?:try\s*\{|catch\s*[({]|\.catch\(|throw new|Error\()/gm);
+    if (errorPatterns && errorPatterns.length >= 3) {
+        const sample = errorPatterns.slice(0, 3).map(l => l.replace(/^\+\s*/, '').trim());
+        solutions.push({
+            name: 'error-handling-pattern',
+            type: 'pattern',
+            tags: ['error', 'handling', 'try-catch', 'pattern'],
+            identifiers: sample.filter(s => s.length >= 4).slice(0, 3),
+            context: 'Error handling approach used in this codebase',
+            content: `Consistent error handling: ${sample.join('; ')}`.slice(0, 500),
+        });
+    }
+    // 3. Detect import/dependency patterns
+    const imports = gitDiff.match(/^\+\s*import\s+.+from\s+['"]([^'"]+)['"]/gm);
+    if (imports && imports.length >= 3) {
+        const packages = imports
+            .map(i => i.match(/from\s+['"]([^'"]+)['"]/)?.[1])
+            .filter((p) => !!p && !p.startsWith('.'))
+            .filter((v, i, a) => a.indexOf(v) === i);
+        if (packages.length >= 2) {
+            solutions.push({
+                name: 'dependency-stack',
+                type: 'decision',
+                tags: ['dependency', 'stack', ...packages.slice(0, 3)],
+                identifiers: packages.filter(p => p.length >= 4).slice(0, 5),
+                context: 'Technology stack and dependency choices',
+                content: `Project uses: ${packages.join(', ')}`,
+            });
+        }
+    }
+    // 4. Detect from commit messages
+    const commitKeywords = {
+        'fix': { type: 'troubleshoot', tags: ['bugfix', 'troubleshoot'] },
+        'refactor': { type: 'pattern', tags: ['refactor', 'cleanup'] },
+        'test': { type: 'pattern', tags: ['testing', 'tdd'] },
+        'security': { type: 'pattern', tags: ['security', 'hardening'] },
+    };
+    for (const [keyword, meta] of Object.entries(commitKeywords)) {
+        const re = new RegExp(`^[a-f0-9]+\\s+${keyword}[:\\s](.+)$`, 'gim');
+        const matches = [...gitLog.matchAll(re)];
+        if (matches.length >= 2) {
+            const descriptions = matches.map(m => m[1].trim()).slice(0, 3);
+            const commitIdentifiers = descriptions
+                .join(' ')
+                .match(/\b[a-zA-Z][a-zA-Z0-9]*(?:[A-Z][a-z]+)+\b|\b[a-z]+(?:_[a-z]+)+\b/g)
+                ?.filter(id => id.length >= 6)
+                ?.filter((v, i, a) => a.indexOf(v) === i)
+                ?.slice(0, 5) ?? [];
+            solutions.push({
+                name: `${keyword}-pattern`,
+                type: meta.type,
+                tags: [...meta.tags, keyword],
+                identifiers: commitIdentifiers,
+                context: `Recurring ${keyword} pattern from commit history`,
+                content: descriptions.join('. ').slice(0, 500),
+            });
+        }
+    }
+    return solutions.slice(0, 3);
+}

package/dist/engine/extraction-gates.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Quality gates for compound extraction.
+ *
+ * Extracted from compound-extractor.ts — validation and dedup logic that
+ * determines whether an extracted solution is worth persisting.
+ */
+import type { SolutionType } from './solution-format.js';
+/** Shape of a solution extracted from git diff or session context */
+export interface ExtractedSolution {
+    name: string;
+    type: SolutionType;
+    tags: string[];
+    identifiers: string[];
+    context: string;
+    content: string;
+}
+/** Gate 0: Is this extraction worth doing? */
+export declare function gate0(stats: {
+    files: number;
+    lines: number;
+    hasCodeFiles: boolean;
+}): boolean;
+/** Gate 1: Structural validation (pure — does not mutate input) */
+export declare function gate1(sol: ExtractedSolution): boolean;
+/** Gate 2: Toxicity filter */
+export declare function gate2(sol: ExtractedSolution): boolean;
+/**
+ * Gate 2.5: Trivial pattern rejection — 자명한 패턴은 축적할 가치 없음.
+ */
+export declare function gateTrivial(sol: ExtractedSolution): boolean;
+/** Gate 3: Dedup check against existing solutions */
+export declare function gate3(sol: ExtractedSolution): 'new' | 're-extract' | 'duplicate';
+/** Evaluate an extracted solution against all quality gates */
+export declare function evaluateExtractedSolution(sol: ExtractedSolution): {
+    action: 'accept' | 'skip' | 'duplicate' | 're-extract';
+    message?: string;
+};

package/dist/engine/extraction-gates.js

@@ -0,0 +1,100 @@
+/**
+ * Quality gates for compound extraction.
+ *
+ * Extracted from compound-extractor.ts — validation and dedup logic that
+ * determines whether an extracted solution is worth persisting.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS } from '../core/paths.js';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('extraction-gates');
+const TOXICITY_PATTERNS = [
+    /@ts-ignore/i, /@ts-nocheck/i, /as\s+any\b/i,
+    /--force\b/i, /--no-verify\b/i, /--skip-ci\b/i,
+    /eslint-disable/i, /prettier-ignore/i, /noqa/i,
+    /\bTODO:/i, /\bFIXME:/i, /\bHACK:/i, /\bXXX:/i,
+    /\/Users\//i, /\/home\//i, /C:\\\\Users/i,
+];
+/** Gate 0: Is this extraction worth doing? */
+export function gate0(stats) {
+    if (stats.files < 1)
+        return false;
+    if (stats.lines < 30)
+        return false;
+    if (!stats.hasCodeFiles)
+        return false;
+    return true;
+}
+/** Gate 1: Structural validation (pure — does not mutate input) */
+export function gate1(sol) {
+    if (!sol.name || sol.name.length < 3)
+        return false;
+    if (!sol.tags || sol.tags.length === 0)
+        return false;
+    if (!sol.content || sol.content.length < 50)
+        return false;
+    if (!sol.context)
+        return false;
+    return true;
+}
+/** Gate 2: Toxicity filter */
+export function gate2(sol) {
+    const text = `${sol.context} ${sol.content}`;
+    return !TOXICITY_PATTERNS.some(p => p.test(text));
+}
+/**
+ * Gate 2.5: Trivial pattern rejection — 자명한 패턴은 축적할 가치 없음.
+ */
+export function gateTrivial(sol) {
+    const content = sol.content.trim();
+    if (content.length < 80)
+        return false;
+    if (/^주로\s/.test(content) && content.split('\n').length < 3)
+        return false;
+    if (sol.identifiers.length === 0 && sol.tags.length < 3)
+        return false;
+    return true;
+}
+/** Gate 3: Dedup check against existing solutions */
+export function gate3(sol) {
+    if (!fs.existsSync(ME_SOLUTIONS))
+        return 'new';
+    try {
+        const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(ME_SOLUTIONS, file), 'utf-8');
+            const tagMatch = content.match(/tags:\s*\[([^\]]*)\]/);
+            if (!tagMatch)
+                continue;
+            const existingTags = tagMatch[1].split(',').map(t => t.trim().replace(/"/g, ''));
+            const overlap = sol.tags.filter(t => existingTags.includes(t));
+            const overlapRatio = overlap.length / Math.max(sol.tags.length, existingTags.length, 1);
+            if (overlapRatio >= 0.7) {
+                if (content.includes('status: "experiment"') || content.includes("status: 'experiment'") || content.includes('status: experiment')) {
+                    return 're-extract';
+                }
+                return 'duplicate';
+            }
+        }
+    }
+    catch (e) {
+        log.debug('gate3 기존 솔루션 파일 읽기 실패 — new로 간주', e);
+    }
+    return 'new';
+}
+/** Evaluate an extracted solution against all quality gates */
+export function evaluateExtractedSolution(sol) {
+    if (!gate1(sol))
+        return { action: 'skip', message: `${sol.name ?? 'unnamed'}: Gate 1 실패 (구조 검증)` };
+    if (!gate2(sol))
+        return { action: 'skip', message: `${sol.name}: Gate 2 실패 (독성 필터)` };
+    if (!gateTrivial(sol))
+        return { action: 'skip', message: `${sol.name}: Gate 2.5 실패 (자명한 패턴)` };
+    const dupResult = gate3(sol);
+    if (dupResult === 'duplicate')
+        return { action: 'duplicate', message: `${sol.name}: Gate 3 중복` };
+    if (dupResult === 're-extract')
+        return { action: 're-extract', message: `${sol.name}: 재추출 (기존 솔루션 강화)` };
+    return { action: 'accept' };
+}

package/dist/engine/extraction-git.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Git helpers for compound extraction.
+ *
+ * Extracted from compound-extractor.ts — pure functions that shell out to git
+ * for commit/diff data. All use execFileSync to prevent shell injection.
+ */
+/** Validate that a string is a valid git SHA (7-64 hex chars) */
+export declare function isValidSha(sha: string): boolean;
+/** Get new commits since last extraction */
+export declare function getNewCommits(cwd: string, lastSha: string): string;
+/** Get commit messages for "why" context enrichment */
+export declare function getCommitMessages(cwd: string, lastSha: string): string;
+/** Get git diff for extraction */
+export declare function getGitDiff(cwd: string, lastSha: string): string;
+/** Get diff stats for Gate 0 */
+export declare function getDiffStats(cwd: string, lastSha: string): {
+    files: number;
+    lines: number;
+    hasCodeFiles: boolean;
+};

package/dist/engine/extraction-git.js

@@ -0,0 +1,75 @@
+/**
+ * Git helpers for compound extraction.
+ *
+ * Extracted from compound-extractor.ts — pure functions that shell out to git
+ * for commit/diff data. All use execFileSync to prevent shell injection.
+ */
+import { execFileSync } from 'node:child_process';
+const MAX_DIFF_LENGTH = 3000;
+/** Validate that a string is a valid git SHA (7-64 hex chars) */
+export function isValidSha(sha) {
+    return /^[a-f0-9]{7,64}$/.test(sha);
+}
+/** Get new commits since last extraction */
+export function getNewCommits(cwd, lastSha) {
+    try {
+        if (!lastSha || !isValidSha(lastSha)) {
+            return execFileSync('git', ['log', '--oneline', '-5'], { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
+        }
+        return execFileSync('git', ['log', '--oneline', `${lastSha}..HEAD`], { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    catch {
+        return '';
+    }
+}
+/** Get commit messages for "why" context enrichment */
+export function getCommitMessages(cwd, lastSha) {
+    try {
+        const args = lastSha && isValidSha(lastSha)
+            ? ['log', '--format=%B', `${lastSha}..HEAD`]
+            : ['log', '--format=%B', '-5'];
+        const msgs = execFileSync('git', args, { cwd, encoding: 'utf-8', timeout: 5000 });
+        return msgs.slice(0, 1000).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Get git diff for extraction */
+export function getGitDiff(cwd, lastSha) {
+    try {
+        const args = lastSha && isValidSha(lastSha)
+            ? ['diff', `${lastSha}..HEAD`]
+            : ['diff', 'HEAD~1'];
+        const diff = execFileSync('git', args, { cwd, encoding: 'utf-8', timeout: 10000 });
+        return diff.slice(0, MAX_DIFF_LENGTH);
+    }
+    catch {
+        return '';
+    }
+}
+/** Get diff stats for Gate 0 */
+export function getDiffStats(cwd, lastSha) {
+    try {
+        const args = lastSha && isValidSha(lastSha)
+            ? ['diff', '--stat', `${lastSha}..HEAD`]
+            : ['diff', '--stat', 'HEAD~1'];
+        const stat = execFileSync('git', args, { cwd, encoding: 'utf-8', timeout: 5000 });
+        const lines = stat.split('\n').filter(l => l.trim());
+        const codeExts = /\.(ts|tsx|js|jsx|py|rs|go|java|rb|c|cpp|h|swift|kt)$/;
+        const hasCodeFiles = lines.some(line => {
+            const filePath = line.split('|')[0]?.trim() ?? '';
+            return codeExts.test(filePath);
+        });
+        const lastLine = lines[lines.length - 1] ?? '';
+        const changedMatch = lastLine.match(/(\d+)\s+files?\s+changed/);
+        const insertMatch = lastLine.match(/(\d+)\s+insertion/);
+        const deleteMatch = lastLine.match(/(\d+)\s+deletion/);
+        const fileCount = parseInt(changedMatch?.[1] ?? '0', 10);
+        const lineCount = parseInt(insertMatch?.[1] ?? '0', 10) + parseInt(deleteMatch?.[1] ?? '0', 10);
+        return { files: fileCount, lines: lineCount, hasCodeFiles };
+    }
+    catch {
+        return { files: 0, lines: 0, hasCodeFiles: false };
+    }
+}

package/dist/engine/extraction-persistence.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Solution persistence for compound extraction.
+ *
+ * Extracted from compound-extractor.ts — saving extracted solutions,
+ * updating re-extraction counters, and managing extraction state.
+ */
+import type { ExtractedSolution } from './extraction-gates.js';
+export interface LastExtraction {
+    lastCommitSha: string;
+    lastExtractedAt: string;
+    extractionsToday: number;
+    todayDate: string;
+}
+/** Load last extraction state */
+export declare function loadLastExtraction(): LastExtraction;
+/** Save last extraction state */
+export declare function saveLastExtraction(state: LastExtraction): void;
+/** Save an extracted solution as experiment */
+export declare function saveExtractedSolution(sol: ExtractedSolution, _sessionId: string): string | null;
+/**
+ * Increment reExtracted counter on existing solution that matches given tags.
+ */
+export declare function updateReExtractedCounter(tags: string[]): void;
+/**
+ * Observability: detect references to existing solutions in new content → emit acted_on.
+ */
+export declare function emitCompoundExtractActedOn(sessionId: string, newSolutionName: string, newContent: string, newSupersedes: string | null): void;

package/dist/engine/extraction-persistence.js

@@ -0,0 +1,140 @@
+/**
+ * Solution persistence for compound extraction.
+ *
+ * Extracted from compound-extractor.ts — saving extracted solutions,
+ * updating re-extraction counters, and managing extraction state.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS, STATE_DIR } from '../core/paths.js';
+import { createLogger } from '../core/logger.js';
+import { emitSolutionEvent } from '../core/observability-store.js';
+import { serializeSolutionV3, DEFAULT_EVIDENCE } from './solution-format.js';
+import { atomicWriteJSON, atomicWriteText } from '../hooks/shared/atomic-write.js';
+import { mutateSolutionFile } from './solution-writer.js';
+const log = createLogger('extraction-persistence');
+const LAST_EXTRACTION_PATH = path.join(STATE_DIR, 'last-extraction.json');
+/** Load last extraction state */
+export function loadLastExtraction() {
+    try {
+        if (fs.existsSync(LAST_EXTRACTION_PATH)) {
+            return JSON.parse(fs.readFileSync(LAST_EXTRACTION_PATH, 'utf-8'));
+        }
+    }
+    catch (e) {
+        log.debug('last extraction state read failed — may cause duplicate extractions', e);
+    }
+    return { lastCommitSha: '', lastExtractedAt: '', extractionsToday: 0, todayDate: '' };
+}
+/** Save last extraction state */
+export function saveLastExtraction(state) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    atomicWriteJSON(LAST_EXTRACTION_PATH, state);
+}
+/** Save an extracted solution as experiment */
+export function saveExtractedSolution(sol, _sessionId) {
+    const today = new Date().toISOString().split('T')[0];
+    const slugName = sol.name.toLowerCase()
+        .replace(/[^a-z0-9가-힣\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 60) || `untitled-${Date.now()}`;
+    const solution = {
+        frontmatter: {
+            name: slugName,
+            version: 1,
+            status: 'experiment',
+            confidence: 0.3,
+            type: sol.type,
+            scope: 'me',
+            tags: sol.tags.slice(0, 5),
+            identifiers: sol.identifiers.filter(id => id.length >= 4),
+            evidence: { ...DEFAULT_EVIDENCE },
+            created: today,
+            updated: today,
+            supersedes: null,
+            extractedBy: 'auto',
+        },
+        context: sol.context,
+        content: sol.content,
+    };
+    const filePath = path.join(ME_SOLUTIONS, `${slugName}.md`);
+    if (fs.existsSync(filePath))
+        return null;
+    fs.mkdirSync(ME_SOLUTIONS, { recursive: true });
+    atomicWriteText(filePath, serializeSolutionV3(solution));
+    return slugName;
+}
+/**
+ * Increment reExtracted counter on existing solution that matches given tags.
+ */
+export function updateReExtractedCounter(tags) {
+    if (!fs.existsSync(ME_SOLUTIONS))
+        return;
+    const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+        const filePath = path.join(ME_SOLUTIONS, file);
+        try {
+            if (fs.lstatSync(filePath).isSymbolicLink())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        let preview;
+        try {
+            preview = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const tagMatch = preview.match(/tags:\s*\[([^\]]*)\]/);
+        if (!tagMatch)
+            continue;
+        const existingTags = tagMatch[1].split(',').map(t => t.trim().replace(/"/g, ''));
+        const overlap = tags.filter(t => existingTags.includes(t));
+        if (overlap.length / Math.max(tags.length, existingTags.length, 1) < 0.7)
+            continue;
+        mutateSolutionFile(filePath, sol => {
+            sol.frontmatter.evidence.reExtracted = (sol.frontmatter.evidence.reExtracted ?? 0) + 1;
+            return true;
+        });
+        return;
+    }
+}
+/**
+ * Observability: detect references to existing solutions in new content → emit acted_on.
+ */
+export function emitCompoundExtractActedOn(sessionId, newSolutionName, newContent, newSupersedes) {
+    try {
+        if (!fs.existsSync(ME_SOLUTIONS))
+            return;
+        const bodyLower = newContent.toLowerCase();
+        const supersedes = newSupersedes ?? '';
+        const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+            const existingName = path.basename(file, '.md');
+            if (existingName === newSolutionName)
+                continue;
+            const referenced = (supersedes && existingName === supersedes)
+                || bodyLower.includes(existingName.toLowerCase());
+            if (!referenced)
+                continue;
+            emitSolutionEvent({
+                sessionId,
+                solutionId: existingName,
+                eventType: 'acted_on',
+                signalSource: 'compound-extract',
+                signalScore: 0.20,
+                meta: {
+                    new_solution: newSolutionName,
+                    via: (supersedes && existingName === supersedes) ? 'supersedes' : 'body-mention',
+                },
+            });
+        }
+    }
+    catch (e) {
+        log.debug('emitCompoundExtractActedOn 실패', e);
+    }
+}

package/dist/engine/extraction-session.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Session context extraction for compound knowledge.
+ *
+ * Extracted from compound-extractor.ts — reads Claude session JSONL files
+ * to extract prompts and write history correlated to a specific project.
+ */
+import type { ExtractedSolution } from './extraction-gates.js';
+interface WriteContextEntry {
+    filePath: string;
+    contentSnippet: string;
+    fileExtension: string;
+}
+export declare function loadPromptHistoryFallback(): string[];
+/**
+ * Load Claude session prompts + writes correlated to `cwd`.
+ *
+ * Exported primarily for test assertions (the `claude-session-context`
+ * tests verify correlation logic directly).
+ */
+export declare function loadClaudeProjectSessionContext(cwd: string, lastExtractedAt: string): {
+    prompts: string[];
+    writes: WriteContextEntry[];
+};
+/** Extract patterns from accumulated session context (prompts + writes + diff) */
+export declare function extractFromSessionContext(gitDiff: string, cwd: string, lastExtractedAt: string): ExtractedSolution[];
+export {};