@wooojin/forgen 0.4.12 → 0.5.0

package/dist/engine/compound-extractor.js

@@ -21,6 +21,7 @@ import { getNewCommits, getCommitMessages, getGitDiff, getDiffStats } from './ex
 import { gate0, evaluateExtractedSolution } from './extraction-gates.js';
 import { extractFromDiff } from './extraction-diff.js';
 import { extractFromSessionContext } from './extraction-session.js';
+import { stripPrivate, isFullyPrivate } from './private-filter.js';
 import { loadLastExtraction, saveLastExtraction, saveExtractedSolution, updateReExtractedCounter, emitCompoundExtractActedOn, } from './extraction-persistence.js';
 const log = createLogger('compound-extractor');
 const MAX_EXTRACTIONS_PER_DAY = 5;
@@ -172,6 +173,15 @@ export function processExtractionResults(rawJson, sessionId) {
         return { saved, skipped };
     }
     for (const sol of solutions.slice(0, 3)) {
+        // W2-5 (private 태그): <private> 범위를 솔루션 content/context 에서 제거 후 저장.
+        // 통째로 private 이면 저장 skip (학습 코퍼스에 남기지 않음).
+        if (isFullyPrivate(sol.content) || isFullyPrivate(sol.context ?? '')) {
+            skipped.push(`${sol.name}: <private> (제외)`);
+            continue;
+        }
+        sol.content = stripPrivate(sol.content).cleaned;
+        if (sol.context)
+            sol.context = stripPrivate(sol.context).cleaned;
         const evaluation = evaluateExtractedSolution(sol);
         if (evaluation.action === 'skip' || evaluation.action === 'duplicate') {
             skipped.push(evaluation.message ?? `${sol.name}: skipped`);

package/dist/engine/compound-loop.js

@@ -190,11 +190,17 @@ export async function handleCompound(args) {
     forgen compound --lifecycle      Run promotion/demotion/circuit-breaker check
     forgen compound --verify <name>  Manually promote solution to verified
 
-  Export/Import:
+  Export/Import (whole store, tar.gz):
     forgen compound export [--output path]
                                      Export knowledge to tar.gz archive
     forgen compound import <path>    Import knowledge from archive (skip existing)
 
+  Export/Import (per-pattern, JSON — with confidence + provenance):
+    forgen compound export <name...> [--out file]
+                                     Export named solutions/rules as a portable bundle
+    forgen compound import <bundle.json> [--dry-run]
+                                     Import a bundle (probation trust, never overwrites)
+
   Auto-extraction:
     forgen compound --pause-auto     Pause auto-extraction
     forgen compound --resume-auto    Resume auto-extraction
@@ -205,15 +211,38 @@ export async function handleCompound(args) {
         return;
     }
     // --- export command ---
+    // 통짜 tar.gz export(플래그만, positional 없음) vs 이름 지정 패턴 export를
+    // positional 인자 유무로 구분한다. `compound export foo` = 패턴 export,
+    // `compound export --output x` = 기존 whole-store export.
     if (args[0] === 'export') {
-        const { handleExport } = await import('./compound-export.js');
-        await handleExport(args.slice(1));
+        const rest = args.slice(1);
+        const hasPatternNames = rest.length > 0 && !rest[0].startsWith('--');
+        if (hasPatternNames) {
+            const { handleShareExport } = await import('./compound-share.js');
+            await handleShareExport(rest);
+        }
+        else {
+            const { handleExport } = await import('./compound-export.js');
+            await handleExport(rest);
+        }
         return;
     }
     // --- import command ---
+    // 대상 파일이 JSON 패턴 번들인지 tar.gz 아카이브인지 확장자/매직바이트로
+    // sniff해서 라우팅한다 (looksLikeShareBundle). 기존 tar.gz import 동작은
+    // 그대로 유지.
     if (args[0] === 'import') {
-        const { handleImport } = await import('./compound-export.js');
-        await handleImport(args.slice(1));
+        const rest = args.slice(1);
+        const filePath = rest.find(a => !a.startsWith('--'));
+        const { looksLikeShareBundle } = await import('./compound-share.js');
+        if (filePath && looksLikeShareBundle(path.resolve(filePath))) {
+            const { handleShareImport } = await import('./compound-share.js');
+            await handleShareImport(rest);
+        }
+        else {
+            const { handleImport } = await import('./compound-export.js');
+            await handleImport(rest);
+        }
         return;
     }
     // --pause-auto / --resume-auto
@@ -399,7 +428,7 @@ export async function handleCompound(args) {
         '--lifecycle', '--verify', '--save', '--interactive',
         'list', 'inspect', 'remove', 'rollback', 'retag', 'lifecycle',
         '--list', '--inspect', '--remove', '--rollback', '--retag', '--since', 'interactive',
-        'export', 'import', '--output',
+        'export', 'import', '--output', '--out', '--dry-run',
     ];
     const hasTypeFlag = knownFlags.some(f => args.includes(f));
     if (!hasTypeFlag) {

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

@@ -0,0 +1,85 @@
+/**
+ * Forgen — Compound Pattern Share (패턴별 export/import)
+ *
+ * `compound-export.ts`의 `export`/`import`는 `~/.forgen/me/` 전체를 tar.gz로
+ * 통짜 백업/이관한다. 이 모듈은 그와 달리 **이름 지정된 패턴 단위**로 신뢰도
+ * (confidence/status/evidence)와 provenance를 함께 담은 JSON 번들을 만들고,
+ * 받는 쪽에서 안전하게 병합한다 (ECC `/instinct-import/export` 대응, OSS gap #1).
+ *
+ * 핵심 설계:
+ *   - 번들은 스키마 버전 고정 JSON. 최상위/패턴 필드 모두 화이트리스트 검증 —
+ *     예상 못한 필드가 있으면 통째로 reject (실행 가능한 콘텐츠가 섞여 들어올
+ *     여지 자체를 차단).
+ *   - 패턴마다 contentHash(sha256)를 동봉 — import 시 재계산해 일치하지 않으면
+ *     reject (변조/손상 탐지).
+ *   - 이름 충돌 시: 로컬 콘텐츠 해시가 같으면 "동일 패턴 재발견"으로 간주해
+ *     `reExtracted` 카운터만 증가(기존 신뢰도는 건드리지 않음 — 이미 solution-writer.ts
+ *     의 dual-path 금지 불변식과 일치). 다르면 절대 덮어쓰지 않고 suffix된
+ *     이름으로 새로 생성.
+ *   - 신규 생성되는 패턴은 항상 probation: status='experiment', confidence는
+ *     신규 솔루션 표준 베이스라인(statusConfidence('experiment')=0.3, 참고:
+ *     extraction-persistence.ts saveExtractedSolution)을 상한으로 export 시점
+ *     confidence의 절반만 반영. evidence는 전부 0으로 리셋 — exporter의 로컬
+ *     사용 이력을 이 머신이 검증 없이 물려받지 않는다. 이후 승급은 기존
+ *     compound-lifecycle.ts의 단일 경로(runLifecycleCheck)로만 진행된다.
+ */
+import { type SolutionFrontmatter } from './solution-format.js';
+export declare const SHARE_BUNDLE_SCHEMA_VERSION: 1;
+export interface ShareBundlePatternV1 {
+    name: string;
+    category: 'solution' | 'rule';
+    frontmatter: SolutionFrontmatter;
+    context: string;
+    content: string;
+    /** sha256(type + sorted tags/identifiers + context + content) — confidence/evidence/timestamp 제외한 콘텐츠 지문. */
+    contentHash: string;
+}
+export interface ShareBundleV1 {
+    schemaVersion: 1;
+    exportedAt: string;
+    /** sha256(hostname:username) 앞 16자 — 원본 식별용, PII 비가역. */
+    originHash: string;
+    patterns: ShareBundlePatternV1[];
+}
+export interface BuildBundleResult {
+    bundle: ShareBundleV1;
+    notFound: string[];
+    rejectedSecrets: string[];
+}
+/**
+ * 이름 목록으로 패턴 번들 생성.
+ *
+ * 시크릿 감지된 패턴은 조용히 스킵하지 않고 `rejectedSecrets`로 보고하되,
+ * 번들 자체는 나머지 clean한 패턴으로 계속 진행한다 (부분 실패 허용).
+ */
+export declare function buildShareBundle(names: string[]): BuildBundleResult;
+export interface ShareBundleValidation {
+    ok: boolean;
+    bundle: ShareBundleV1 | null;
+    errors: string[];
+}
+/**
+ * 번들 검증: 크기 캡 → 최상위 필드 화이트리스트 → 패턴별 필드 화이트리스트 →
+ * frontmatter 정합성 → contentHash 재계산 일치. 하나라도 실패하면 번들 전체를
+ * reject한다 (부분 신뢰 없음 — 손상/변조된 번들은 통째로 버린다).
+ */
+export declare function validateShareBundle(raw: unknown, rawSize: number): ShareBundleValidation;
+export interface ShareImportAction {
+    sourceName: string;
+    category: 'solution' | 'rule';
+    action: 'merge-reextract' | 'create' | 'create-suffixed';
+    targetName: string;
+    detail: string;
+}
+export interface ShareImportSummary {
+    dryRun: boolean;
+    actions: ShareImportAction[];
+}
+/** dry-run과 실제 실행이 공유하는 계획 수립 — 파일시스템에 아무것도 쓰지 않는다. */
+export declare function planShareImport(bundle: ShareBundleV1): ShareImportAction[];
+export declare function executeShareImport(bundle: ShareBundleV1, opts?: {
+    dryRun?: boolean;
+}): ShareImportSummary;
+export declare function looksLikeShareBundle(filePath: string): boolean;
+export declare function handleShareExport(args: string[]): Promise<void>;
+export declare function handleShareImport(args: string[]): Promise<void>;