@wooojin/forgen 0.4.10 → 0.4.11

package/dist/core/workflows-cli.d.ts

@@ -0,0 +1,26 @@
+/**
+ * forgen workflows — dynamic-workflow 템플릿 설치/조회 (ADR-009 §3).
+ *
+ * dynamic workflows 는 플러그인 매니페스트로 번들할 수 없고(research preview,
+ * `.claude/workflows/` 에만 저장됨), forgen 은 철학을 인코딩한 canonical 템플릿을
+ * `assets/claude/workflows/*.js` 로 동봉한다. 이 명령이 그것을 사용자의
+ * `.claude/workflows/` 로 복사한다 → `/<name>` 으로 실행 가능.
+ *
+ * forgen-verify 에이전트(verify 스테이지용)는 플러그인 `agents` 키로 자동 배포되므로
+ * 별도 설치가 필요 없다.
+ *
+ *   forgen workflows install            ~/.claude/workflows/ (개인, 모든 프로젝트)
+ *   forgen workflows install --project  <cwd>/.claude/workflows/ (저장소 공유)
+ *   forgen workflows list               동봉 템플릿 + 설치 여부
+ */
+/** forgen pkg root 의 assets/claude/workflows 디렉토리. invoke-agent 와 동일 walk-up. */
+export declare function findTemplatesDir(): string;
+/** 템플릿 파일명(.js) 목록. 실패 시 []. */
+export declare function listTemplates(templatesDir: string): string[];
+export interface InstallResult {
+    installed: string[];
+    targetDir: string;
+}
+/** 템플릿을 targetDir 로 복사 (DI — 테스트 주입용). 기존 파일은 덮어쓴다. */
+export declare function installWorkflows(templatesDir: string, targetDir: string): InstallResult;
+export declare function handleWorkflows(args: string[]): Promise<void>;

package/dist/core/workflows-cli.js

@@ -0,0 +1,120 @@
+/**
+ * forgen workflows — dynamic-workflow 템플릿 설치/조회 (ADR-009 §3).
+ *
+ * dynamic workflows 는 플러그인 매니페스트로 번들할 수 없고(research preview,
+ * `.claude/workflows/` 에만 저장됨), forgen 은 철학을 인코딩한 canonical 템플릿을
+ * `assets/claude/workflows/*.js` 로 동봉한다. 이 명령이 그것을 사용자의
+ * `.claude/workflows/` 로 복사한다 → `/<name>` 으로 실행 가능.
+ *
+ * forgen-verify 에이전트(verify 스테이지용)는 플러그인 `agents` 키로 자동 배포되므로
+ * 별도 설치가 필요 없다.
+ *
+ *   forgen workflows install            ~/.claude/workflows/ (개인, 모든 프로젝트)
+ *   forgen workflows install --project  <cwd>/.claude/workflows/ (저장소 공유)
+ *   forgen workflows list               동봉 템플릿 + 설치 여부
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const isTTY = process.stdout.isTTY;
+const C = {
+    reset: isTTY ? '\x1b[0m' : '',
+    bold: isTTY ? '\x1b[1m' : '',
+    dim: isTTY ? '\x1b[2m' : '',
+    green: isTTY ? '\x1b[32m' : '',
+    cyan: isTTY ? '\x1b[36m' : '',
+};
+/** forgen pkg root 의 assets/claude/workflows 디렉토리. invoke-agent 와 동일 walk-up. */
+export function findTemplatesDir() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 8; depth += 1) {
+        const pkgJson = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
+                if (pkg.name === '@wooojin/forgen') {
+                    const candidate = path.join(dir, 'assets', 'claude', 'workflows');
+                    if (fs.existsSync(candidate))
+                        return candidate;
+                }
+            }
+            catch { /* fallthrough */ }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error('forgen workflows: pkg root + assets/claude/workflows/ not found');
+}
+/** 템플릿 파일명(.js) 목록. 실패 시 []. */
+export function listTemplates(templatesDir) {
+    try {
+        return fs.readdirSync(templatesDir).filter((f) => f.endsWith('.js')).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** 템플릿을 targetDir 로 복사 (DI — 테스트 주입용). 기존 파일은 덮어쓴다. */
+export function installWorkflows(templatesDir, targetDir) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    const installed = [];
+    for (const file of listTemplates(templatesDir)) {
+        fs.copyFileSync(path.join(templatesDir, file), path.join(targetDir, file));
+        installed.push(file);
+    }
+    return { installed, targetDir };
+}
+function resolveTargetBase(projectScope) {
+    return projectScope ? process.cwd() : os.homedir();
+}
+export async function handleWorkflows(args) {
+    const sub = args[0] ?? 'list';
+    const projectScope = args.includes('--project');
+    let templatesDir;
+    try {
+        templatesDir = findTemplatesDir();
+    }
+    catch {
+        console.log(`\n  ${C.dim}워크플로우 템플릿을 찾을 수 없습니다 (forgen 설치 확인).${C.reset}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (sub === 'install') {
+        const targetDir = path.join(resolveTargetBase(projectScope), '.claude', 'workflows');
+        const { installed } = installWorkflows(templatesDir, targetDir);
+        if (installed.length === 0) {
+            console.log(`\n  ${C.dim}동봉된 템플릿이 없습니다.${C.reset}\n`);
+            return;
+        }
+        console.log(`\n  ${C.green}✓${C.reset} ${installed.length} workflow templates → ${C.cyan}${targetDir}${C.reset}`);
+        for (const f of installed)
+            console.log(`      /${f.replace(/\.js$/, '')}`);
+        console.log(`\n  ${C.dim}Claude Code 에서 /<name> 으로 실행. verify 스테이지는 forgen-verify 에이전트 사용.${C.reset}\n`);
+        return;
+    }
+    if (sub === 'list') {
+        const templates = listTemplates(templatesDir);
+        const homeDir = path.join(os.homedir(), '.claude', 'workflows');
+        const projDir = path.join(process.cwd(), '.claude', 'workflows');
+        console.log(`\n  ${C.bold}forgen workflow templates${C.reset}\n`);
+        for (const f of templates) {
+            const name = f.replace(/\.js$/, '');
+            const inHome = fs.existsSync(path.join(homeDir, f));
+            const inProj = fs.existsSync(path.join(projDir, f));
+            const where = [inHome && 'user', inProj && 'project'].filter(Boolean).join('+') || 'not installed';
+            console.log(`    ${inHome || inProj ? C.green + '✓' + C.reset : C.dim + '·' + C.reset} /${name}  ${C.dim}(${where})${C.reset}`);
+        }
+        console.log(`\n  ${C.dim}install: forgen workflows install [--project]${C.reset}\n`);
+        return;
+    }
+    console.log(`
+  ${C.bold}forgen workflows${C.reset} — dynamic-workflow 템플릿 (ADR-009 §3)
+
+  Usage:
+    forgen workflows install [--project]   템플릿을 .claude/workflows/ 로 복사
+    forgen workflows list                  동봉 템플릿 + 설치 여부
+`);
+}

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

@@ -50,6 +50,18 @@ export declare function exportKnowledge(outputPath?: string): ExportResult;
  * added.
  */
 export declare function importKnowledge(archivePath: string): ImportResult;
+/**
+ * Selective export — filter to specific categories.
+ * `--only solutions,rules` exports only those two directories.
+ */
+export declare function exportKnowledgeSelective(categories: string[], outputPath?: string): ExportResult;
+/**
+ * Import with merge mode — updates existing files instead of skipping them.
+ * Newer files in the archive overwrite older local files.
+ */
+export declare function importKnowledgeMerge(archivePath: string): ImportResult & {
+    merged: number;
+};
 /** CLI handler: forgen compound export */
 export declare function handleExport(args: string[]): Promise<void>;
 /** CLI handler: forgen compound import */

package/dist/engine/compound-export.js

@@ -152,14 +152,116 @@ export function importKnowledge(archivePath) {
         fs.rmSync(tmpDir, { recursive: true, force: true });
     }
 }
+/**
+ * Selective export — filter to specific categories.
+ * `--only solutions,rules` exports only those two directories.
+ */
+export function exportKnowledgeSelective(categories, outputPath) {
+    const date = new Date().toISOString().split('T')[0];
+    const resolved = outputPath ?? path.join(process.cwd(), `forgen-knowledge-${date}.tar.gz`);
+    const validCategories = categories.filter(c => KNOWLEDGE_DIRS.includes(c));
+    if (validCategories.length === 0) {
+        throw new Error(`No valid categories. Choose from: ${KNOWLEDGE_DIRS.join(', ')}`);
+    }
+    const counts = {};
+    const existingDirs = [];
+    for (const name of validCategories) {
+        const dir = path.join(ME_DIR, name);
+        const count = countFiles(dir);
+        counts[name] = count;
+        if (fs.existsSync(dir)) {
+            existingDirs.push(name);
+        }
+    }
+    const totalFiles = Object.values(counts).reduce((a, b) => a + b, 0);
+    if (existingDirs.length === 0) {
+        throw new Error('No knowledge directories found to export.');
+    }
+    const outDir = path.dirname(resolved);
+    fs.mkdirSync(outDir, { recursive: true });
+    execFileSync('tar', ['czf', resolved, ...existingDirs], {
+        cwd: ME_DIR,
+        timeout: 30000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { outputPath: resolved, counts, totalFiles };
+}
+/**
+ * Import with merge mode — updates existing files instead of skipping them.
+ * Newer files in the archive overwrite older local files.
+ */
+export function importKnowledgeMerge(archivePath) {
+    if (!fs.existsSync(archivePath)) {
+        throw new Error(`Archive not found: ${archivePath}`);
+    }
+    const listOutput = execFileSync('tar', ['tzf', archivePath], {
+        timeout: 30000,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const archiveFiles = listOutput
+        .split('\n')
+        .map(f => f.trim())
+        .filter(f => f && !f.endsWith('/'));
+    const tmpDir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'forgen-merge-'));
+    try {
+        execFileSync('tar', ['xzf', archivePath, '-C', tmpDir], {
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const result = { imported: 0, skipped: 0, merged: 0, details: [] };
+        const meDirCanon = path.resolve(ME_DIR) + path.sep;
+        const tmpDirCanon = path.resolve(tmpDir) + path.sep;
+        for (const relFile of archiveFiles) {
+            const srcPath = path.resolve(path.join(tmpDir, relFile));
+            const destPath = path.resolve(path.join(ME_DIR, relFile));
+            if (!isPathInside(meDirCanon, destPath) || !isPathInside(tmpDirCanon, srcPath)) {
+                result.skipped++;
+                result.details.push({ file: relFile, action: 'skipped' });
+                continue;
+            }
+            if (fs.existsSync(destPath)) {
+                const srcMtime = fs.statSync(srcPath).mtimeMs;
+                const destMtime = fs.statSync(destPath).mtimeMs;
+                if (srcMtime > destMtime) {
+                    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                    fs.copyFileSync(srcPath, destPath);
+                    result.merged++;
+                    result.details.push({ file: relFile, action: 'imported' });
+                }
+                else {
+                    result.skipped++;
+                    result.details.push({ file: relFile, action: 'skipped' });
+                }
+            }
+            else {
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                fs.copyFileSync(srcPath, destPath);
+                result.imported++;
+                result.details.push({ file: relFile, action: 'imported' });
+            }
+        }
+        return result;
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
 /** CLI handler: forgen compound export */
 export async function handleExport(args) {
     const outputIdx = args.indexOf('--output');
     const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : undefined;
+    const onlyIdx = args.indexOf('--only');
+    const onlyCategories = onlyIdx !== -1 ? (args[onlyIdx + 1] ?? '').split(',').filter(Boolean) : [];
     try {
-        const result = exportKnowledge(outputPath);
+        const result = onlyCategories.length > 0
+            ? exportKnowledgeSelective(onlyCategories, outputPath)
+            : exportKnowledge(outputPath);
         console.log('\n  Compound Knowledge Export\n');
         console.log(`  Output: ${result.outputPath}`);
+        if (onlyCategories.length > 0) {
+            console.log(`  Filter: ${onlyCategories.join(', ')}`);
+        }
         console.log();
         for (const [category, count] of Object.entries(result.counts)) {
             console.log(`    ${category}: ${count} files`);
@@ -173,23 +275,43 @@ export async function handleExport(args) {
 }
 /** CLI handler: forgen compound import */
 export async function handleImport(args) {
-    const archivePath = args[0];
-    if (!archivePath || archivePath.startsWith('--')) {
-        console.log('  Usage: forgen compound import <path-to-archive>\n');
+    const filteredArgs = args.filter(a => !a.startsWith('--'));
+    const archivePath = filteredArgs[0];
+    const mergeMode = args.includes('--merge');
+    if (!archivePath) {
+        console.log('  Usage: forgen compound import <path-to-archive> [--merge]\n');
+        console.log('  --merge  Update existing files if archive version is newer');
         return;
     }
     try {
         const resolved = path.resolve(archivePath);
-        const result = importKnowledge(resolved);
-        console.log('\n  Compound Knowledge Import\n');
-        console.log(`  Archive: ${resolved}`);
-        console.log(`  Imported: ${result.imported} new files`);
-        console.log(`  Skipped: ${result.skipped} existing files`);
-        if (result.details.length > 0 && result.details.length <= 20) {
-            console.log();
-            for (const d of result.details) {
-                const icon = d.action === 'imported' ? '+' : '-';
-                console.log(`    ${icon} ${d.file}`);
+        if (mergeMode) {
+            const result = importKnowledgeMerge(resolved);
+            console.log('\n  Compound Knowledge Import (merge mode)\n');
+            console.log(`  Archive: ${resolved}`);
+            console.log(`  New:     ${result.imported} files`);
+            console.log(`  Merged:  ${result.merged} files (newer version overwrote local)`);
+            console.log(`  Skipped: ${result.skipped} files (local is same or newer)`);
+            if (result.details.length > 0 && result.details.length <= 20) {
+                console.log();
+                for (const d of result.details) {
+                    const icon = d.action === 'imported' ? '+' : '-';
+                    console.log(`    ${icon} ${d.file}`);
+                }
+            }
+        }
+        else {
+            const result = importKnowledge(resolved);
+            console.log('\n  Compound Knowledge Import\n');
+            console.log(`  Archive: ${resolved}`);
+            console.log(`  Imported: ${result.imported} new files`);
+            console.log(`  Skipped: ${result.skipped} existing files`);
+            if (result.details.length > 0 && result.details.length <= 20) {
+                console.log();
+                for (const d of result.details) {
+                    const icon = d.action === 'imported' ? '+' : '-';
+                    console.log(`    ${icon} ${d.file}`);
+                }
             }
         }
         console.log();

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

@@ -1,54 +1,24 @@
 /**
- * Forgen — Compound Knowledge Extractor
+ * Forgen — Compound Knowledge Extractor (facade)
  *
- * Extracts reusable patterns and decisions from git history and session context.
- * Runs quality gates (structure, toxicity, trivial, dedup) before persisting solutions.
+ * Orchestrates extraction pipeline: git analysis → quality gates →
+ * pattern extraction → persistence. Re-exports from decomposed modules.
  *
- * 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
+ * Module layout (post-decomposition):
+ *   extraction-git.ts         — getNewCommits, getCommitMessages, getGitDiff, getDiffStats
+ *   extraction-gates.ts       — gate0-gate3, gateTrivial, evaluateExtractedSolution, ExtractedSolution
+ *   extraction-diff.ts        — extractFromDiff, findCommonPrefix
+ *   extraction-session.ts     — extractFromSessionContext, loadClaudeProjectSessionContext
+ *   extraction-persistence.ts — saveExtractedSolution, updateReExtractedCounter, LastExtraction
  */
-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[];
-};
+import type { ExtractedSolution } from './extraction-gates.js';
+export { loadClaudeProjectSessionContext } from './extraction-session.js';
+export type { ExtractedSolution } from './extraction-gates.js';
 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[];
@@ -65,4 +35,3 @@ export declare function isExtractionPaused(): boolean;
 export declare function pauseExtraction(): void;
 /** Resume auto-extraction */
 export declare function resumeExtraction(): void;
-export {};