@wooojin/forgen 0.1.0

package/dist/core/inspect-cli.js

@@ -0,0 +1,47 @@
+/**
+ * Forgen v1 — Inspect CLI
+ *
+ * forgen inspect profile|rules|evidence|session
+ * Authoritative: docs/plans/2026-04-03-forgen-rule-renderer-spec.md §6
+ */
+import { loadProfile } from '../store/profile-store.js';
+import { loadAllRules } from '../store/rule-store.js';
+import { loadRecentEvidence } from '../store/evidence-store.js';
+import { loadRecentSessions } from '../store/session-state-store.js';
+import * as inspect from '../renderer/inspect-renderer.js';
+export async function handleInspect(args) {
+    const sub = args[0];
+    if (sub === 'profile') {
+        const profile = loadProfile();
+        if (!profile) {
+            console.log('\n  No v1 profile found. Run onboarding first.\n');
+            return;
+        }
+        console.log('\n' + inspect.renderProfile(profile) + '\n');
+        return;
+    }
+    if (sub === 'rules') {
+        const rules = loadAllRules();
+        console.log('\n' + inspect.renderRules(rules) + '\n');
+        return;
+    }
+    if (sub === 'evidence') {
+        const evidence = loadRecentEvidence(20);
+        console.log('\n' + inspect.renderEvidence(evidence) + '\n');
+        return;
+    }
+    if (sub === 'session') {
+        const sessions = loadRecentSessions(1);
+        if (sessions.length === 0) {
+            console.log('\n  No session state found.\n');
+            return;
+        }
+        console.log('\n' + inspect.renderSession(sessions[0]) + '\n');
+        return;
+    }
+    console.log(`  Usage:
+    forgen inspect profile   — 현재 profile 상태
+    forgen inspect rules     — active/suppressed 규칙 목록
+    forgen inspect evidence  — 최근 evidence 목록
+    forgen inspect session   — 현재/최근 세션 상태`);
+}

package/dist/core/legacy-detector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Forgen v1 — Legacy Detector
+ *
+ * ~/.compound/ 5D profile 감지, backup, cutover 분기.
+ * Authoritative spec:
+ *   docs/plans/2026-04-03-forgen-lifecycle-design.md §12
+ *   docs/plans/2026-04-03-forgen-data-model-storage-spec.md §11
+ *
+ * cutover 순서:
+ * 1. ~/.compound/me/forge-profile.json 존재 여부 확인
+ * 2. 5D schema인지 검사
+ * 3. legacy면 backup (forge-profile.legacy-<ts>.json)
+ * 4. 새 profile은 ~/.forgen/me/forge-profile.json에 생성 → fresh onboarding
+ */
+export interface LegacyCheckResult {
+    found: boolean;
+    isLegacy: boolean;
+    backupPath: string | null;
+}
+/**
+ * ~/.compound/me/forge-profile.json이 5D legacy인지 확인.
+ */
+export declare function checkLegacyProfile(): LegacyCheckResult;
+/**
+ * legacy profile을 backup.
+ * ~/.compound/me/forge-profile.legacy-<timestamp>.json으로 복사.
+ */
+export declare function backupLegacyProfile(): string | null;
+/**
+ * legacy cutover 전체 실행.
+ * 반환: backup 경로 (legacy가 아니면 null)
+ */
+export declare function runLegacyCutover(): string | null;

package/dist/core/legacy-detector.js

@@ -0,0 +1,66 @@
+/**
+ * Forgen v1 — Legacy Detector
+ *
+ * ~/.compound/ 5D profile 감지, backup, cutover 분기.
+ * Authoritative spec:
+ *   docs/plans/2026-04-03-forgen-lifecycle-design.md §12
+ *   docs/plans/2026-04-03-forgen-data-model-storage-spec.md §11
+ *
+ * cutover 순서:
+ * 1. ~/.compound/me/forge-profile.json 존재 여부 확인
+ * 2. 5D schema인지 검사
+ * 3. legacy면 backup (forge-profile.legacy-<ts>.json)
+ * 4. 새 profile은 ~/.forgen/me/forge-profile.json에 생성 → fresh onboarding
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { FORGE_PROFILE } from './paths.js';
+import { safeReadJSON } from '../hooks/shared/atomic-write.js';
+// 5D schema의 핵심 필드
+const LEGACY_FIELDS = ['riskTolerance', 'autonomyPreference', 'qualityFocus', 'abstractionLevel', 'communicationStyle'];
+/**
+ * ~/.compound/me/forge-profile.json이 5D legacy인지 확인.
+ */
+export function checkLegacyProfile() {
+    if (!fs.existsSync(FORGE_PROFILE)) {
+        return { found: false, isLegacy: false, backupPath: null };
+    }
+    const data = safeReadJSON(FORGE_PROFILE, {});
+    // model_version이 2.x면 이미 v1 마이그레이션 완료
+    if (typeof data.model_version === 'string' && data.model_version.startsWith('2.')) {
+        return { found: true, isLegacy: false, backupPath: null };
+    }
+    // 5D 필드 존재 여부로 legacy 판정
+    const dimensions = data.dimensions;
+    if (dimensions && LEGACY_FIELDS.some(f => f in dimensions)) {
+        return { found: true, isLegacy: true, backupPath: null };
+    }
+    // dimensions가 없더라도 model_version이 없으면 legacy로 간주
+    if (!data.model_version) {
+        return { found: true, isLegacy: true, backupPath: null };
+    }
+    return { found: true, isLegacy: false, backupPath: null };
+}
+/**
+ * legacy profile을 backup.
+ * ~/.compound/me/forge-profile.legacy-<timestamp>.json으로 복사.
+ */
+export function backupLegacyProfile() {
+    if (!fs.existsSync(FORGE_PROFILE))
+        return null;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = path.join(path.dirname(FORGE_PROFILE), `forge-profile.legacy-${timestamp}.json`);
+    fs.copyFileSync(FORGE_PROFILE, backupPath);
+    return backupPath;
+}
+/**
+ * legacy cutover 전체 실행.
+ * 반환: backup 경로 (legacy가 아니면 null)
+ */
+export function runLegacyCutover() {
+    const check = checkLegacyProfile();
+    if (!check.found || !check.isLegacy)
+        return null;
+    const backupPath = backupLegacyProfile();
+    return backupPath;
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Forgen — Unified Logger
+ *
+ * 환경변수:
+ *   FORGEN_LOG_LEVEL   — debug | info | warn | error (기본: info)
+ *   FORGEN_DEBUG       — 활성화할 namespace 목록 (쉼표 구분, 예: 'provider,hook')
+ *                        '*' 이면 전체 네임스페이스 활성화
+ *   COMPOUND_DEBUG=1   — 레거시 호환: 전체 debug 출력 활성화 (FORGEN_DEBUG='*' 와 동일)
+ *
+ * 출력 형식: [forgen:namespace] message
+ * 출력 스트림: stderr (CLI 사용자 출력과 분리)
+ *
+ * ADR: debugLog()를 직접 대체하지 않고 내부 구현으로 유지.
+ *      기존 호출자는 현행 동작을 유지하면서 점진적으로 createLogger()로 마이그레이션.
+ */
+export declare enum LogLevel {
+    debug = 0,
+    info = 1,
+    warn = 2,
+    error = 3
+}
+export declare class Logger {
+    readonly namespace: string;
+    constructor(namespace: string);
+    private shouldOutput;
+    private write;
+    debug(msg: string, error?: unknown): void;
+    info(msg: string, error?: unknown): void;
+    warn(msg: string, error?: unknown): void;
+    error(msg: string, error?: unknown): void;
+}
+/** namespace 기반 Logger 인스턴스 팩토리 */
+export declare function createLogger(namespace: string): Logger;
+export declare function debugLog(context: string, msg: string, error?: unknown): void;

package/dist/core/logger.js

@@ -0,0 +1,121 @@
+/**
+ * Forgen — Unified Logger
+ *
+ * 환경변수:
+ *   FORGEN_LOG_LEVEL   — debug | info | warn | error (기본: info)
+ *   FORGEN_DEBUG       — 활성화할 namespace 목록 (쉼표 구분, 예: 'provider,hook')
+ *                        '*' 이면 전체 네임스페이스 활성화
+ *   COMPOUND_DEBUG=1   — 레거시 호환: 전체 debug 출력 활성화 (FORGEN_DEBUG='*' 와 동일)
+ *
+ * 출력 형식: [forgen:namespace] message
+ * 출력 스트림: stderr (CLI 사용자 출력과 분리)
+ *
+ * ADR: debugLog()를 직접 대체하지 않고 내부 구현으로 유지.
+ *      기존 호출자는 현행 동작을 유지하면서 점진적으로 createLogger()로 마이그레이션.
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["debug"] = 0] = "debug";
+    LogLevel[LogLevel["info"] = 1] = "info";
+    LogLevel[LogLevel["warn"] = 2] = "warn";
+    LogLevel[LogLevel["error"] = 3] = "error";
+})(LogLevel || (LogLevel = {}));
+const LEVEL_LABELS = {
+    [LogLevel.debug]: 'debug',
+    [LogLevel.info]: 'info',
+    [LogLevel.warn]: 'warn',
+    [LogLevel.error]: 'error',
+};
+function parseLogLevel(raw) {
+    switch (raw?.toLowerCase()) {
+        case 'debug': return LogLevel.debug;
+        case 'warn': return LogLevel.warn;
+        case 'error': return LogLevel.error;
+        case 'info': return LogLevel.info;
+        default:
+            // COMPOUND_DEBUG=1이 설정되어 있고 FORGEN_LOG_LEVEL이 명시되지 않으면 debug 레벨로 동작
+            if (process.env.FORGEN_DEBUG === '1' || process.env.COMPOUND_DEBUG === '1')
+                return LogLevel.debug;
+            return LogLevel.info;
+    }
+}
+function resolveEnabledNamespaces() {
+    // 레거시 COMPOUND_DEBUG=1 → 전체 활성화
+    if (process.env.FORGEN_DEBUG === '1' || process.env.COMPOUND_DEBUG === '1')
+        return '*';
+    const raw = process.env.FORGEN_DEBUG;
+    if (!raw)
+        return null;
+    if (raw === '*')
+        return '*';
+    return new Set(raw.split(',').map(s => s.trim()).filter(Boolean));
+}
+export class Logger {
+    namespace;
+    constructor(namespace) {
+        this.namespace = namespace;
+    }
+    shouldOutput(level) {
+        const configuredLevel = parseLogLevel(process.env.FORGEN_LOG_LEVEL);
+        // info 이상은 namespace 필터 무관하게 레벨만 체크
+        if (level >= LogLevel.info) {
+            return level >= configuredLevel;
+        }
+        // debug 레벨: namespace 필터 + 레벨 체크 모두 통과해야 함
+        if (level < configuredLevel)
+            return false;
+        const enabled = resolveEnabledNamespaces();
+        if (enabled === null)
+            return false;
+        if (enabled === '*')
+            return true;
+        return enabled.has(this.namespace);
+    }
+    write(level, msg, error) {
+        if (!this.shouldOutput(level))
+            return;
+        const label = LEVEL_LABELS[level];
+        const errPart = error !== undefined
+            ? `: ${error instanceof Error ? error.message : String(error)}`
+            : '';
+        const line = `[forgen:${this.namespace}] [${label}] ${msg}${errPart}`;
+        // warn/error → console.error, debug/info → console.error (stderr, CLI 출력과 분리)
+        console.error(line);
+    }
+    debug(msg, error) { this.write(LogLevel.debug, msg, error); }
+    info(msg, error) { this.write(LogLevel.info, msg, error); }
+    warn(msg, error) { this.write(LogLevel.warn, msg, error); }
+    error(msg, error) { this.write(LogLevel.error, msg, error); }
+}
+/** namespace 기반 Logger 인스턴스 팩토리 */
+export function createLogger(namespace) {
+    return new Logger(namespace);
+}
+// ── 레거시 호환 API ──────────────────────────────────────────────────────────
+//
+// 기존 debugLog(context, msg, error?) 호출자는 변경 없이 동작합니다.
+// 내부적으로 createLogger를 사용하여 동일한 환경변수 제어를 따릅니다.
+// 레거시 형식 출력: [CH:context] message  (기존 형식 유지로 로그 파서 호환)
+export function debugLog(context, msg, error) {
+    // 레거시 호환: COMPOUND_DEBUG=1이면 레벨 체크 없이 무조건 출력
+    // FORGEN_LOG_LEVEL이 명시적으로 설정된 경우에만 레벨 우선순위를 따름
+    const isLegacyForced = process.env.FORGEN_DEBUG === '1' || process.env.COMPOUND_DEBUG === '1';
+    if (!isLegacyForced) {
+        const configuredLevel = parseLogLevel(process.env.FORGEN_LOG_LEVEL);
+        if (LogLevel.debug < configuredLevel)
+            return;
+    }
+    else if (process.env.FORGEN_LOG_LEVEL) {
+        // COMPOUND_DEBUG=1이더라도 명시적 LOG_LEVEL 설정은 존중
+        const configuredLevel = parseLogLevel(process.env.FORGEN_LOG_LEVEL);
+        if (LogLevel.debug < configuredLevel)
+            return;
+    }
+    const enabled = resolveEnabledNamespaces();
+    if (enabled === null && !isLegacyForced)
+        return;
+    if (enabled !== null && enabled !== '*' && !enabled.has(context))
+        return;
+    const errMsg = error instanceof Error ? error.message : String(error ?? '');
+    console.error(`[CH:${context}] ${msg}${errMsg ? `: ${errMsg}` : ''}`);
+}

package/dist/core/mcp-config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * mcp-config.ts — MCP 서버 설정 생성기
+ *
+ * Claude Code settings.json의 mcpServers 섹션을 관리한다.
+ * - 기본 MCP 서버 템플릿 제공 (filesystem, fetch, context7, playwright)
+ * - 설정 생성 및 주입 (기존 설정과 병합, 덮어쓰기 없음)
+ * - CLI 핸들러: forgen mcp list/add/remove/templates
+ */
+/** MCP 서버 단일 설정 */
+export interface McpServerConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+/**
+ * 기본 MCP 서버 템플릿 목록 반환
+ * 반환값: 서버 이름 → 설정 객체 맵
+ */
+export declare function getDefaultMcpTemplates(): Record<string, McpServerConfig>;
+/**
+ * 선택한 서버 이름 목록을 받아 McpServerConfig 맵 생성
+ * 알 수 없는 서버 이름은 경고 출력 후 무시
+ */
+export declare function generateMcpConfig(servers: string[]): Record<string, McpServerConfig>;
+/**
+ * ~/.claude/settings.json의 mcpServers에 서버 설정 주입
+ * 기존 mcpServers와 병합 (같은 이름의 서버가 있으면 덮어씀)
+ */
+export declare function injectMcpServers(servers: Record<string, McpServerConfig>): void;
+/**
+ * 현재 ~/.claude/settings.json에 등록된 MCP 서버 목록 반환
+ * settings.json이 없거나 mcpServers가 없으면 빈 객체 반환
+ */
+export declare function listInstalledMcpServers(): Record<string, McpServerConfig>;
+/**
+ * MCP CLI 핸들러
+ *
+ * 사용법:
+ *   forgen mcp list                    — 설치된 MCP 서버 목록
+ *   forgen mcp templates               — 사용 가능한 기본 템플릿 목록
+ *   forgen mcp add <name> [<name>...]  — MCP 서버 추가 (템플릿 기준)
+ *   forgen mcp remove <name>           — MCP 서버 제거
+ */
+export declare function handleMcp(args: string[]): Promise<void>;

package/dist/core/mcp-config.js

@@ -0,0 +1,177 @@
+/**
+ * mcp-config.ts — MCP 서버 설정 생성기
+ *
+ * Claude Code settings.json의 mcpServers 섹션을 관리한다.
+ * - 기본 MCP 서버 템플릿 제공 (filesystem, fetch, context7, playwright)
+ * - 설정 생성 및 주입 (기존 설정과 병합, 덮어쓰기 없음)
+ * - CLI 핸들러: forgen mcp list/add/remove/templates
+ */
+import { readSettings, writeSettings } from './settings-lock.js';
+/** 기본 MCP 서버 템플릿 맵 */
+const DEFAULT_MCP_TEMPLATES = {
+    filesystem: {
+        command: 'npx',
+        args: ['-y', '@anthropic-ai/mcp-server-filesystem', '--allow-dir', '.'],
+    },
+    fetch: {
+        command: 'npx',
+        args: ['-y', '@anthropic-ai/mcp-server-fetch'],
+    },
+    context7: {
+        command: 'npx',
+        args: ['-y', '@upstash/context7-mcp'],
+    },
+    playwright: {
+        command: 'npx',
+        args: ['-y', '@anthropic-ai/mcp-server-playwright'],
+    },
+};
+/**
+ * 기본 MCP 서버 템플릿 목록 반환
+ * 반환값: 서버 이름 → 설정 객체 맵
+ */
+export function getDefaultMcpTemplates() {
+    const result = {};
+    for (const [k, v] of Object.entries(DEFAULT_MCP_TEMPLATES)) {
+        result[k] = { ...v, args: [...v.args], ...(v.env ? { env: { ...v.env } } : {}) };
+    }
+    return result;
+}
+/**
+ * 선택한 서버 이름 목록을 받아 McpServerConfig 맵 생성
+ * 알 수 없는 서버 이름은 경고 출력 후 무시
+ */
+export function generateMcpConfig(servers) {
+    const templates = getDefaultMcpTemplates();
+    const result = {};
+    for (const name of servers) {
+        if (templates[name]) {
+            result[name] = { ...templates[name], args: [...templates[name].args] };
+        }
+        else {
+            console.warn(`[mcp-config] Unknown MCP server name: "${name}" — skipping.`);
+        }
+    }
+    return result;
+}
+/**
+ * ~/.claude/settings.json의 mcpServers에 서버 설정 주입
+ * 기존 mcpServers와 병합 (같은 이름의 서버가 있으면 덮어씀)
+ */
+export function injectMcpServers(servers) {
+    const settings = readSettings(); // 파싱 실패 시 throw
+    const existing = settings.mcpServers ?? {};
+    settings.mcpServers = { ...existing, ...servers };
+    writeSettings(settings); // lock + backup + atomic write
+}
+/**
+ * 현재 ~/.claude/settings.json에 등록된 MCP 서버 목록 반환
+ * settings.json이 없거나 mcpServers가 없으면 빈 객체 반환
+ */
+export function listInstalledMcpServers() {
+    try {
+        const settings = readSettings();
+        return settings.mcpServers ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * MCP CLI 핸들러
+ *
+ * 사용법:
+ *   forgen mcp list                    — 설치된 MCP 서버 목록
+ *   forgen mcp templates               — 사용 가능한 기본 템플릿 목록
+ *   forgen mcp add <name> [<name>...]  — MCP 서버 추가 (템플릿 기준)
+ *   forgen mcp remove <name>           — MCP 서버 제거
+ */
+export async function handleMcp(args) {
+    const sub = args[0];
+    if (!sub || sub === 'list') {
+        const installed = listInstalledMcpServers();
+        const names = Object.keys(installed);
+        console.log('\n  Forgen — MCP Servers\n');
+        if (names.length === 0) {
+            console.log('  No MCP servers installed.');
+            console.log('  Use `forgen mcp add <name>` to add one.\n');
+        }
+        else {
+            console.log(`  Installed servers (${names.length}):\n`);
+            for (const name of names) {
+                const cfg = installed[name];
+                console.log(`    ${name}`);
+                console.log(`      command: ${cfg.command} ${cfg.args.join(' ')}`);
+                if (cfg.env && Object.keys(cfg.env).length > 0) {
+                    console.log(`      env: ${JSON.stringify(cfg.env)}`);
+                }
+            }
+            console.log('');
+        }
+        return;
+    }
+    if (sub === 'templates') {
+        const templates = getDefaultMcpTemplates();
+        console.log('\n  Forgen — MCP Templates\n');
+        console.log(`  Available default templates (${Object.keys(templates).length}):\n`);
+        for (const [name, cfg] of Object.entries(templates)) {
+            console.log(`    ${name}`);
+            console.log(`      command: ${cfg.command} ${cfg.args.join(' ')}`);
+        }
+        console.log('');
+        return;
+    }
+    if (sub === 'add') {
+        const serverNames = args.slice(1);
+        if (serverNames.length === 0) {
+            console.error('  Error: Please specify a server name to add.');
+            console.error('  Usage: forgen mcp add <name> [<name>...]');
+            console.error('  Available templates: forgen mcp templates');
+            process.exit(1);
+        }
+        const configs = generateMcpConfig(serverNames);
+        const addedNames = Object.keys(configs);
+        if (addedNames.length === 0) {
+            console.error('  Error: No valid server names provided.');
+            process.exit(1);
+        }
+        injectMcpServers(configs);
+        console.log('\n  Forgen — MCP Add\n');
+        for (const name of addedNames) {
+            console.log(`  ✓ Added: ${name}`);
+        }
+        console.log('');
+        return;
+    }
+    if (sub === 'remove') {
+        const serverName = args[1];
+        if (!serverName) {
+            console.error('  Error: Please specify a server name to remove.');
+            console.error('  Usage: forgen mcp remove <name>');
+            process.exit(1);
+        }
+        let settings;
+        try {
+            settings = readSettings();
+        }
+        catch {
+            console.error('  Error: Failed to parse settings.json');
+            process.exit(1);
+            return;
+        }
+        const mcpServers = settings.mcpServers ?? {};
+        if (!mcpServers[serverName]) {
+            console.log(`  "${serverName}" is not installed.`);
+            return;
+        }
+        delete mcpServers[serverName];
+        settings.mcpServers = mcpServers;
+        writeSettings(settings); // lock + backup + atomic write
+        console.log(`\n  ✓ Removed: ${serverName}\n`);
+        return;
+    }
+    // 알 수 없는 서브커맨드
+    console.error(`  Error: Unknown mcp subcommand: "${sub}"`);
+    console.error('  Usage: forgen mcp [list|templates|add|remove]');
+    process.exit(1);
+}

package/dist/core/notepad.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Forgen — Notepad 코어 모듈
+ *
+ * .compound/notepad.md 파일을 관리합니다.
+ * compaction(컨텍스트 압축)에서 살아남는 영구 컨텍스트 노트 저장소로,
+ * 세션이 바뀌어도 유지되어야 하는 중요 메모를 보관합니다.
+ *
+ * 사용 위치: {프로젝트루트}/.compound/notepad.md
+ */
+/** {repo}/.compound/notepad.md 경로 반환 */
+export declare function getNotepadPath(cwd: string): string;
+/** notepad.md 내용 읽기. 파일이 없으면 빈 문자열 반환. */
+export declare function readNotepad(cwd: string): string;
+/** notepad.md 전체를 content로 덮어쓰기. 부모 디렉토리가 없으면 자동 생성. */
+export declare function writeNotepad(cwd: string, content: string): void;
+/**
+ * notepad.md 끝에 타임스탬프와 함께 항목 추가.
+ * 형식: `\n## [YYYY-MM-DD HH:mm]\n{entry}\n`
+ */
+export declare function appendToNotepad(cwd: string, entry: string): void;
+/** notepad.md 내용 초기화 (빈 파일로 덮어쓰기). */
+export declare function clearNotepad(cwd: string): void;
+/**
+ * CLI 핸들러: `forgen notepad <show|add|edit|clear>`
+ *
+ * - show: 현재 notepad 내용 출력
+ * - add "내용": 타임스탬프와 함께 항목 추가
+ * - edit: notepad.md 파일 경로 출력 (에디터에서 직접 편집용)
+ * - clear: notepad 초기화
+ */
+export declare function handleNotepad(args: string[]): Promise<void>;

package/dist/core/notepad.js

@@ -0,0 +1,88 @@
+/**
+ * Forgen — Notepad 코어 모듈
+ *
+ * .compound/notepad.md 파일을 관리합니다.
+ * compaction(컨텍스트 압축)에서 살아남는 영구 컨텍스트 노트 저장소로,
+ * 세션이 바뀌어도 유지되어야 하는 중요 메모를 보관합니다.
+ *
+ * 사용 위치: {프로젝트루트}/.compound/notepad.md
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { projectDir } from './paths.js';
+/** {repo}/.compound/notepad.md 경로 반환 */
+export function getNotepadPath(cwd) {
+    return path.join(projectDir(cwd), 'notepad.md');
+}
+/** notepad.md 내용 읽기. 파일이 없으면 빈 문자열 반환. */
+export function readNotepad(cwd) {
+    const filePath = getNotepadPath(cwd);
+    if (!fs.existsSync(filePath))
+        return '';
+    return fs.readFileSync(filePath, 'utf-8');
+}
+/** notepad.md 전체를 content로 덮어쓰기. 부모 디렉토리가 없으면 자동 생성. */
+export function writeNotepad(cwd, content) {
+    const filePath = getNotepadPath(cwd);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+/**
+ * notepad.md 끝에 타임스탬프와 함께 항목 추가.
+ * 형식: `\n## [YYYY-MM-DD HH:mm]\n{entry}\n`
+ */
+export function appendToNotepad(cwd, entry) {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}`;
+    const block = `\n## [${timestamp}]\n${entry}\n`;
+    const filePath = getNotepadPath(cwd);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, block, 'utf-8');
+}
+/** notepad.md 내용 초기화 (빈 파일로 덮어쓰기). */
+export function clearNotepad(cwd) {
+    writeNotepad(cwd, '');
+}
+/**
+ * CLI 핸들러: `forgen notepad <show|add|edit|clear>`
+ *
+ * - show: 현재 notepad 내용 출력
+ * - add "내용": 타임스탬프와 함께 항목 추가
+ * - edit: notepad.md 파일 경로 출력 (에디터에서 직접 편집용)
+ * - clear: notepad 초기화
+ */
+export async function handleNotepad(args) {
+    const subcommand = args[0] ?? 'show';
+    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+    if (subcommand === 'show') {
+        const content = readNotepad(cwd);
+        if (!content.trim()) {
+            console.log('  (notepad is empty)');
+        }
+        else {
+            console.log(content);
+        }
+    }
+    else if (subcommand === 'add') {
+        const entry = args.slice(1).join(' ');
+        if (!entry) {
+            console.error('  Usage: forgen notepad add "content to add"');
+            process.exit(1);
+        }
+        appendToNotepad(cwd, entry);
+        console.log('  Added to notepad.');
+    }
+    else if (subcommand === 'edit') {
+        const filePath = getNotepadPath(cwd);
+        console.log(`  Notepad file path: ${filePath}`);
+        console.log(`  Open with your editor: $EDITOR ${filePath}`);
+    }
+    else if (subcommand === 'clear') {
+        clearNotepad(cwd);
+        console.log('  Notepad cleared.');
+    }
+    else {
+        console.log('  Usage: forgen notepad <show|add|edit|clear>');
+    }
+}