@ebowwa/coder 0.2.1 → 0.7.64

package/dist/core/checkpoints.js

@@ -0,0 +1,438 @@
+/**
+ * Checkpoint Manager - Save and restore conversation states
+ * Captures both chat context AND code/file changes
+ */
+import { randomUUID } from "crypto";
+import { execSync } from "child_process";
+const CHECKPOINTS_DIR = process.env.CLAUDE_CHECKPOINTS_DIR || `${process.env.HOME}/.claude/checkpoints`;
+/**
+ * Generate a simple hash for file content
+ */
+function hashContent(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+}
+/**
+ * Get current git state
+ */
+function getGitState(workingDir) {
+    try {
+        // Check if we're in a git repo
+        execSync("git rev-parse --is-inside-work-tree", {
+            cwd: workingDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+            cwd: workingDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        // Get ahead/behind counts
+        let ahead = 0;
+        let behind = 0;
+        try {
+            const counts = execSync("git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null || echo '0 0'", {
+                cwd: workingDir,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"]
+            }).trim().split(/\s+/);
+            behind = parseInt(counts[0] || "0", 10);
+            ahead = parseInt(counts[1] || "0", 10);
+        }
+        catch {
+            // No upstream
+        }
+        const status = execSync("git status --porcelain", {
+            cwd: workingDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        const staged = [];
+        const unstaged = [];
+        const untracked = [];
+        for (const line of status.split("\n")) {
+            if (!line.trim())
+                continue;
+            const indexStatus = line[0];
+            const workTreeStatus = line[1];
+            const filePath = line.slice(3);
+            if (indexStatus === "?" && workTreeStatus === "?") {
+                untracked.push(filePath);
+            }
+            else if (indexStatus !== " " && indexStatus !== "?") {
+                staged.push(filePath);
+            }
+            else if (workTreeStatus !== " ") {
+                unstaged.push(filePath);
+            }
+        }
+        return { branch, ahead, behind, staged, unstaged, untracked };
+    }
+    catch (error) {
+        // Not in a git repo or git not available
+        return undefined;
+    }
+}
+/**
+ * Create a git stash with checkpoint info
+ */
+function createCheckpointStash(workingDir, checkpointId) {
+    try {
+        const stashName = `claude-checkpoint-${checkpointId}`;
+        execSync(`git stash push -m "${stashName}" --include-untracked 2>/dev/null || true`, {
+            cwd: workingDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        return stashName;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Capture file snapshots for modified files
+ */
+async function captureFileSnapshots(workingDir, filePaths) {
+    const snapshots = [];
+    for (const filePath of filePaths) {
+        try {
+            const fullPath = `${workingDir}/${filePath}`;
+            const file = Bun.file(fullPath);
+            if (await file.exists()) {
+                const content = await file.text();
+                snapshots.push({
+                    path: filePath,
+                    content,
+                    hash: hashContent(content),
+                });
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return snapshots;
+}
+/**
+ * Restore files from snapshots
+ */
+async function restoreFileSnapshots(workingDir, snapshots) {
+    let restored = 0;
+    let failed = 0;
+    for (const snapshot of snapshots) {
+        try {
+            const fullPath = `${workingDir}/${snapshot.path}`;
+            await Bun.write(fullPath, snapshot.content);
+            restored++;
+        }
+        catch {
+            failed++;
+        }
+    }
+    return { restored, failed };
+}
+/**
+ * Ensure checkpoints directory exists
+ */
+async function ensureCheckpointsDir() {
+    const dir = Bun.file(CHECKPOINTS_DIR);
+    if (!(await dir.exists())) {
+        await Bun.write(CHECKPOINTS_DIR + "/.gitkeep", "");
+    }
+}
+/**
+ * Get checkpoint file path for a session
+ */
+function getCheckpointFilePath(sessionId) {
+    return `${CHECKPOINTS_DIR}/${sessionId}.json`;
+}
+/**
+ * Load checkpoints for a session
+ */
+export async function loadCheckpoints(sessionId) {
+    const checkpoints = new Map();
+    try {
+        const filePath = getCheckpointFilePath(sessionId);
+        const file = Bun.file(filePath);
+        if (await file.exists()) {
+            const content = await file.text();
+            const data = JSON.parse(content);
+            for (const checkpoint of data) {
+                checkpoints.set(checkpoint.id, checkpoint);
+            }
+        }
+    }
+    catch (error) {
+        // Return empty map on error
+    }
+    return checkpoints;
+}
+/**
+ * Save checkpoints for a session
+ */
+export async function saveCheckpoints(sessionId, checkpoints) {
+    await ensureCheckpointsDir();
+    const filePath = getCheckpointFilePath(sessionId);
+    const data = Array.from(checkpoints.values());
+    await Bun.write(filePath, JSON.stringify(data, null, 2));
+}
+/**
+ * Create a new checkpoint with file snapshots
+ */
+export async function createCheckpoint(sessionId, messages, options = {}) {
+    const checkpoints = await loadCheckpoints(sessionId);
+    const workingDir = options.workingDirectory || process.cwd();
+    // Capture git state
+    const gitState = getGitState(workingDir);
+    // Capture file snapshots for all changed files
+    let fileSnapshots = [];
+    if (options.trackFiles !== false && gitState) {
+        const changedFiles = [
+            ...gitState.staged,
+            ...gitState.unstaged,
+            ...gitState.untracked,
+        ];
+        fileSnapshots = await captureFileSnapshots(workingDir, changedFiles);
+    }
+    const checkpoint = {
+        id: randomUUID().slice(0, 8),
+        sessionId,
+        timestamp: Date.now(),
+        label: options.label || `Checkpoint ${checkpoints.size + 1}`,
+        description: options.description,
+        messages: JSON.parse(JSON.stringify(messages)), // Deep copy
+        files: fileSnapshots,
+        gitState,
+        metadata: {
+            model: options.model,
+            workingDirectory: workingDir,
+            totalCost: options.totalCost || 0,
+            messageCount: messages.length,
+            fileCount: fileSnapshots.length,
+        },
+    };
+    checkpoints.set(checkpoint.id, checkpoint);
+    await saveCheckpoints(sessionId, checkpoints);
+    return checkpoint;
+}
+/**
+ * Restore a checkpoint (returns the checkpoint, doesn't apply it)
+ */
+export async function restoreCheckpoint(sessionId, checkpointId) {
+    const checkpoints = await loadCheckpoints(sessionId);
+    return checkpoints.get(checkpointId) || null;
+}
+/**
+ * Apply a checkpoint - restore files and return messages
+ */
+export async function applyCheckpoint(checkpoint, options = {}) {
+    const workingDir = options.workingDirectory || checkpoint.metadata.workingDirectory || process.cwd();
+    let filesRestored = 0;
+    let filesFailed = 0;
+    // Restore files if requested
+    if (options.restoreFiles !== false && checkpoint.files.length > 0) {
+        const result = await restoreFileSnapshots(workingDir, checkpoint.files);
+        filesRestored = result.restored;
+        filesFailed = result.failed;
+    }
+    return {
+        messages: options.restoreMessages !== false ? checkpoint.messages : [],
+        filesRestored,
+        filesFailed,
+    };
+}
+/**
+ * Delete a checkpoint
+ */
+export async function deleteCheckpoint(sessionId, checkpointId) {
+    const checkpoints = await loadCheckpoints(sessionId);
+    if (checkpoints.has(checkpointId)) {
+        checkpoints.delete(checkpointId);
+        await saveCheckpoints(sessionId, checkpoints);
+        return true;
+    }
+    return false;
+}
+/**
+ * List all checkpoints for a session
+ */
+export async function listCheckpoints(sessionId) {
+    const checkpoints = await loadCheckpoints(sessionId);
+    return Array.from(checkpoints.values()).sort((a, b) => b.timestamp - a.timestamp);
+}
+/**
+ * Format checkpoint for display
+ */
+export function formatCheckpoint(checkpoint, verbose = false) {
+    const date = new Date(checkpoint.timestamp);
+    const timeStr = date.toLocaleTimeString();
+    const dateStr = date.toLocaleDateString();
+    let output = `\x1b[33m${checkpoint.id}\x1b[0m `;
+    output += `\x1b[1m${checkpoint.label}\x1b[0m `;
+    output += `\x1b[90m(${dateStr} ${timeStr})\x1b[0m`;
+    // Show file count if there are files
+    if (checkpoint.files.length > 0) {
+        output += ` \x1b[32m[${checkpoint.files.length} files]\x1b[0m`;
+    }
+    // Show git branch if available
+    if (checkpoint.gitState) {
+        output += ` \x1b[34m(${checkpoint.gitState.branch})\x1b[0m`;
+    }
+    if (verbose) {
+        output += `\n  Messages: ${checkpoint.metadata.messageCount}`;
+        output += `\n  Files: ${checkpoint.metadata.fileCount}`;
+        output += `\n  Cost: $${checkpoint.metadata.totalCost.toFixed(4)}`;
+        if (checkpoint.gitState) {
+            const changes = checkpoint.gitState.staged.length +
+                checkpoint.gitState.unstaged.length +
+                checkpoint.gitState.untracked.length;
+            output += `\n  Git changes: ${changes}`;
+        }
+        if (checkpoint.description) {
+            output += `\n  ${checkpoint.description}`;
+        }
+    }
+    return output;
+}
+/**
+ * Print checkpoints list
+ */
+export function printCheckpointsList(checkpoints) {
+    if (checkpoints.length === 0) {
+        console.log("\x1b[90mNo checkpoints saved.\x1b[0m");
+        console.log("\x1b[90mUse /checkpoint <label> to create one.\x1b[0m");
+        return;
+    }
+    console.log(`\n\x1b[1mCheckpoints (${checkpoints.length}):\x1b[0m`);
+    console.log("\x1b[90m─────────────────────────────────────────────────\x1b[0m");
+    for (const checkpoint of checkpoints) {
+        console.log(formatCheckpoint(checkpoint));
+    }
+    console.log("\x1b[90m─────────────────────────────────────────────────\x1b[0m");
+    console.log("\x1b[90m/restore <id>        - Restore checkpoint (files + chat)\x1b[0m");
+    console.log("\x1b[90m/restore-chat <id>   - Restore chat only (no files)\x1b[0m");
+    console.log("\x1b[90m/checkpoint <label>  - Create new checkpoint\x1b[0m");
+}
+/**
+ * Clear all checkpoints for a session
+ */
+export async function clearCheckpoints(sessionId) {
+    const checkpoints = await loadCheckpoints(sessionId);
+    const count = checkpoints.size;
+    checkpoints.clear();
+    await saveCheckpoints(sessionId, checkpoints);
+    return count;
+}
+/**
+ * Get checkpoint summary for status display
+ */
+export function getCheckpointSummary(checkpoint) {
+    const parts = [];
+    if (checkpoint.files.length > 0) {
+        parts.push(`${checkpoint.files.length} files`);
+    }
+    parts.push(`${checkpoint.metadata.messageCount} msgs`);
+    if (checkpoint.gitState) {
+        const changes = checkpoint.gitState.staged.length +
+            checkpoint.gitState.unstaged.length +
+            checkpoint.gitState.untracked.length;
+        if (changes > 0) {
+            parts.push(`${changes} changes`);
+        }
+    }
+    return parts.join(" | ");
+}
+const NAVIGATION_FILE = (sessionId) => `${CHECKPOINTS_DIR}/${sessionId}-nav.json`;
+/**
+ * Get checkpoint navigation state
+ */
+async function getNavigation(sessionId) {
+    try {
+        const file = Bun.file(NAVIGATION_FILE(sessionId));
+        if (await file.exists()) {
+            return JSON.parse(await file.text());
+        }
+    }
+    catch {
+        // Return fresh navigation
+    }
+    return { sessionId, checkpointIds: [], currentIndex: -1, undoneIds: [] };
+}
+/**
+ * Save checkpoint navigation state
+ */
+async function saveNavigation(nav) {
+    await ensureCheckpointsDir();
+    await Bun.write(NAVIGATION_FILE(nav.sessionId), JSON.stringify(nav, null, 2));
+}
+/**
+ * Register a new checkpoint (called after createCheckpoint)
+ */
+export async function registerCheckpoint(sessionId, checkpointId) {
+    const nav = await getNavigation(sessionId);
+    // If we're not at the end, truncate the list (new checkpoint = no redo)
+    if (nav.currentIndex < nav.checkpointIds.length - 1) {
+        nav.checkpointIds = nav.checkpointIds.slice(0, nav.currentIndex + 1);
+    }
+    nav.checkpointIds.push(checkpointId);
+    nav.currentIndex = nav.checkpointIds.length - 1;
+    nav.undoneIds = []; // Clear redo stack
+    await saveNavigation(nav);
+}
+/**
+ * Undo - go back to previous checkpoint
+ */
+export async function undoCheckpoint(sessionId) {
+    const nav = await getNavigation(sessionId);
+    const checkpoints = await loadCheckpoints(sessionId);
+    if (nav.currentIndex <= 0) {
+        return { checkpoint: null, canRedo: false };
+    }
+    // Save current to redo stack
+    const currentId = nav.checkpointIds[nav.currentIndex];
+    if (currentId) {
+        nav.undoneIds.push(currentId);
+    }
+    // Move back
+    nav.currentIndex--;
+    const prevId = nav.checkpointIds[nav.currentIndex];
+    await saveNavigation(nav);
+    const checkpoint = prevId ? checkpoints.get(prevId) || null : null;
+    return { checkpoint, canRedo: nav.undoneIds.length > 0 };
+}
+/**
+ * Redo - go forward to next checkpoint
+ */
+export async function redoCheckpoint(sessionId) {
+    const nav = await getNavigation(sessionId);
+    const checkpoints = await loadCheckpoints(sessionId);
+    if (nav.undoneIds.length === 0) {
+        return { checkpoint: null, canRedo: false };
+    }
+    // Pop from redo stack
+    const nextId = nav.undoneIds.pop();
+    nav.currentIndex++;
+    await saveNavigation(nav);
+    const checkpoint = checkpoints.get(nextId) || null;
+    return { checkpoint, canRedo: nav.undoneIds.length > 0 };
+}
+/**
+ * Get navigation status
+ */
+export async function getNavigationStatus(sessionId) {
+    const nav = await getNavigation(sessionId);
+    return {
+        total: nav.checkpointIds.length,
+        current: nav.currentIndex + 1, // 1-indexed for display
+        canUndo: nav.currentIndex > 0,
+        canRedo: nav.undoneIds.length > 0,
+        currentId: nav.checkpointIds[nav.currentIndex],
+    };
+}

package/dist/core/claude-md.d.ts

@@ -0,0 +1,71 @@
+/**
+ * CLAUDE.md Support - Load project-specific instructions
+ *
+ * Loads CLAUDE.md files from:
+ * 1. ~/.claude/CLAUDE.md (global user preferences)
+ * 2. .claude/CLAUDE.md (project-specific, preferred)
+ * 3. CLAUDE.md (root level, fallback)
+ *
+ * Content is merged in order: global → project
+ */
+export interface SystemSignature {
+    version: string;
+    projectId: string;
+    sessionId: string;
+    timestamp: number;
+    environment: EnvironmentInfo;
+    gitStatus: GitStatusInfo;
+    tools: ToolsInfo;
+}
+export interface EnvironmentInfo {
+    platform: string;
+    nodeVersion: string;
+    shell: string;
+    homeDir: string;
+}
+export interface GitStatusInfo {
+    branch: string;
+    hasChanges: boolean;
+    staged: number;
+    unstaged: number;
+    untracked: number;
+}
+export interface ToolsInfo {
+    available: string[];
+    mcpServers: string[];
+}
+export interface ClaudeMdConfig {
+    globalPath: string;
+    projectPath: string;
+    rootPath: string;
+}
+/**
+ * Load all CLAUDE.md files and merge them
+ *
+ * Priority (later overrides earlier):
+ * 1. Global (~/.claude/CLAUDE.md)
+ * 2. Project (.claude/CLAUDE.md or ./CLAUDE.md)
+ */
+export declare function loadClaudeMd(workingDirectory?: string, config?: Partial<ClaudeMdConfig>): Promise<{
+    global: string | null;
+    project: string | null;
+    merged: string;
+    sources: string[];
+}>;
+/**
+ * Build system prompt section from CLAUDE.md
+ */
+export declare function buildClaudeMdPrompt(workingDirectory?: string): Promise<string>;
+/**
+ * Generate a system signature for the current environment
+ */
+export declare function generateSystemSignature(workingDirectory?: string, gitStatus?: Partial<GitStatusInfo>, availableTools?: string[], mcpServers?: string[]): SystemSignature;
+/**
+ * Format a system signature as a readable string
+ */
+export declare function formatSystemSignature(signature: SystemSignature): string;
+/**
+ * Watch for CLAUDE.md changes (returns cleanup function)
+ */
+export declare function watchClaudeMd(workingDirectory: string, onChange: () => void): () => void;
+//# sourceMappingURL=claude-md.d.ts.map

package/dist/core/claude-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-md.d.ts","sourceRoot":"","sources":["../../packages/src/core/claude-md.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,eAAe,CAAC;IAC7B,SAAS,EAAE,aAAa,CAAC;IACzB,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAmCD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,gBAAgB,GAAE,MAAsB,EACxC,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM,GACnC,OAAO,CAAC;IACT,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC,CA6CD;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,gBAAgB,GAAE,MAAsB,GACvC,OAAO,CAAC,MAAM,CAAC,CAkBjB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,gBAAgB,GAAE,MAAsB,EACxC,SAAS,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,EAClC,cAAc,CAAC,EAAE,MAAM,EAAE,EACzB,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,eAAe,CAwBjB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,CAyBxE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CA4BZ"}

package/dist/core/claude-md.js

@@ -0,0 +1,198 @@
+/**
+ * CLAUDE.md Support - Load project-specific instructions
+ *
+ * Loads CLAUDE.md files from:
+ * 1. ~/.claude/CLAUDE.md (global user preferences)
+ * 2. .claude/CLAUDE.md (project-specific, preferred)
+ * 3. CLAUDE.md (root level, fallback)
+ *
+ * Content is merged in order: global → project
+ */
+import { readFile, access } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+const DEFAULT_CONFIG = {
+    globalPath: `${process.env.HOME}/.claude/CLAUDE.md`,
+    projectPath: ".claude/CLAUDE.md",
+    rootPath: "CLAUDE.md",
+};
+/**
+ * Check if a file exists and is readable
+ */
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load CLAUDE.md content from a single file
+ */
+async function loadClaudeMdFile(path) {
+    try {
+        if (await fileExists(path)) {
+            const content = await readFile(path, "utf-8");
+            return content.trim();
+        }
+    }
+    catch (error) {
+        // File not readable, skip
+    }
+    return null;
+}
+/**
+ * Load all CLAUDE.md files and merge them
+ *
+ * Priority (later overrides earlier):
+ * 1. Global (~/.claude/CLAUDE.md)
+ * 2. Project (.claude/CLAUDE.md or ./CLAUDE.md)
+ */
+export async function loadClaudeMd(workingDirectory = process.cwd(), config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const sources = [];
+    let globalContent = null;
+    let projectContent = null;
+    // Load global CLAUDE.md
+    const globalPath = cfg.globalPath;
+    globalContent = await loadClaudeMdFile(globalPath);
+    if (globalContent) {
+        sources.push(globalPath);
+    }
+    // Load project CLAUDE.md (prefer .claude/CLAUDE.md over root CLAUDE.md)
+    const projectPath = join(workingDirectory, cfg.projectPath);
+    const rootPath = join(workingDirectory, cfg.rootPath);
+    projectContent = await loadClaudeMdFile(projectPath);
+    if (projectContent) {
+        sources.push(projectPath);
+    }
+    else {
+        // Fallback to root CLAUDE.md
+        projectContent = await loadClaudeMdFile(rootPath);
+        if (projectContent) {
+            sources.push(rootPath);
+        }
+    }
+    // Merge content
+    const parts = [];
+    if (globalContent) {
+        parts.push(`# Global Instructions\n\n${globalContent}`);
+    }
+    if (projectContent) {
+        parts.push(`# Project Instructions\n\n${projectContent}`);
+    }
+    return {
+        global: globalContent,
+        project: projectContent,
+        merged: parts.join("\n\n---\n\n"),
+        sources,
+    };
+}
+/**
+ * Build system prompt section from CLAUDE.md
+ */
+export async function buildClaudeMdPrompt(workingDirectory = process.cwd()) {
+    const { merged, sources } = await loadClaudeMd(workingDirectory);
+    if (!merged) {
+        return "";
+    }
+    const header = sources.length > 0
+        ? `Loaded from: ${sources.join(", ")}`
+        : "";
+    return `
+## Project Instructions
+
+${header}
+
+${merged}
+`;
+}
+/**
+ * Generate a system signature for the current environment
+ */
+export function generateSystemSignature(workingDirectory = process.cwd(), gitStatus, availableTools, mcpServers) {
+    return {
+        version: "1.0.0",
+        projectId: randomUUID(),
+        sessionId: randomUUID(),
+        timestamp: Date.now(),
+        environment: {
+            platform: process.platform,
+            nodeVersion: process.version,
+            shell: process.env.SHELL || "unknown",
+            homeDir: process.env.HOME || "",
+        },
+        gitStatus: {
+            branch: gitStatus?.branch || "unknown",
+            hasChanges: gitStatus?.hasChanges ?? false,
+            staged: gitStatus?.staged ?? 0,
+            unstaged: gitStatus?.unstaged ?? 0,
+            untracked: gitStatus?.untracked ?? 0,
+        },
+        tools: {
+            available: availableTools || [],
+            mcpServers: mcpServers || [],
+        },
+    };
+}
+/**
+ * Format a system signature as a readable string
+ */
+export function formatSystemSignature(signature) {
+    return `
+System Signature
+================
+Version: ${signature.version}
+Project ID: ${signature.projectId}
+Session ID: ${signature.sessionId}
+Timestamp: ${new Date(signature.timestamp).toISOString()}
+
+Environment:
+  Platform: ${signature.environment.platform}
+  Node: ${signature.environment.nodeVersion}
+  Shell: ${signature.environment.shell}
+
+Git Status:
+  Branch: ${signature.gitStatus.branch}
+  Changes: ${signature.gitStatus.hasChanges ? "Yes" : "No"}
+  Staged: ${signature.gitStatus.staged}
+  Unstaged: ${signature.gitStatus.unstaged}
+  Untracked: ${signature.gitStatus.untracked}
+
+Tools:
+  Available: ${signature.tools.available.length}
+  MCP Servers: ${signature.tools.mcpServers.length}
+`;
+}
+/**
+ * Watch for CLAUDE.md changes (returns cleanup function)
+ */
+export function watchClaudeMd(workingDirectory, onChange) {
+    const { watch } = require("fs");
+    const watchers = [];
+    const paths = [
+        `${process.env.HOME}/.claude/CLAUDE.md`,
+        `${workingDirectory}/.claude/CLAUDE.md`,
+        `${workingDirectory}/CLAUDE.md`,
+    ];
+    for (const path of paths) {
+        try {
+            const watcher = watch(path, (eventType) => {
+                if (eventType === "change") {
+                    onChange();
+                }
+            });
+            watchers.push(watcher);
+        }
+        catch {
+            // File doesn't exist, skip watching
+        }
+    }
+    return () => {
+        for (const watcher of watchers) {
+            watcher.close();
+        }
+    };
+}