@nemus-cli/nemus 0.2.1

package/dist/utils/claude-sessions.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspaceSessions = getWorkspaceSessions;
+exports.pathToProjectDirName = pathToProjectDirName;
+exports.extractWorkspaceName = extractWorkspaceName;
+exports.relativeTime = relativeTime;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const agent_config_1 = require("./agent-config");
+/**
+ * Scan session directories for workspace-related session files.
+ * Checks Claude (~/.claude/projects/) and/or Pi (~/.pi/agent/sessions/) based on config.
+ * Returns sessions sorted by last activity (most recent first).
+ *
+ * Note: Pi session discovery has limitations. Pi uses a different naming convention
+ * (--path--with--dashes--) vs Claude's (-path-with-dashes). This scanner currently
+ * only reliably finds Claude sessions. Pi session discovery may require updates
+ * based on Pi's actual session directory structure.
+ */
+async function getWorkspaceSessions() {
+    const agents = (0, agent_config_1.getActiveAgents)();
+    const allSessions = [];
+    // Scan each active agent's session directory
+    for (const agent of agents) {
+        const sessions = await scanProjectsDir(agent.sessionProjectsDir, agent.type);
+        allSessions.push(...sessions);
+    }
+    // Deduplicate by workspace + session ID, sort by most recent
+    const seen = new Set();
+    const deduped = allSessions.filter(s => {
+        const key = `${s.workspacePath}:${s.sessionId}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    deduped.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
+    return deduped;
+}
+/**
+ * Scan a single projects/sessions directory for workspace sessions.
+ */
+async function scanProjectsDir(projectsDir, agentType) {
+    // Only Claude Code and Pi expose a scannable per-project session directory
+    // layout. OpenCode stores sessions in SQLite; Codex/Gemini use their own
+    // formats that aren't scanned here — skip them.
+    if (agentType !== 'claude' && agentType !== 'pi')
+        return [];
+    const workspacesPrefix = pathToProjectDirName(config_1.WORKSPACES_DIR, agentType);
+    let projectDirs;
+    try {
+        projectDirs = await fs.readdir(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    // Filter to only workspace project directories
+    const workspaceProjectDirs = projectDirs.filter(dir => {
+        if (agentType === 'pi') {
+            // Pi dirs: "--{base}-{name}--", so strip trailing -- from prefix to match base + '-'
+            const prefixBase = workspacesPrefix.slice(0, -2); // remove trailing --
+            return dir.startsWith(prefixBase + '-') && dir !== workspacesPrefix;
+        }
+        // Claude: prefix + dash separator
+        return dir.startsWith(workspacesPrefix + '-') && dir !== workspacesPrefix;
+    });
+    const sessions = [];
+    await Promise.all(workspaceProjectDirs.map(async (projDir) => {
+        const workspaceName = extractWorkspaceName(projDir, workspacesPrefix, agentType);
+        if (!workspaceName)
+            return;
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, workspaceName);
+        // Check workspace still exists on disk
+        try {
+            await fs.access(workspacePath);
+        }
+        catch {
+            return; // Workspace deleted, skip
+        }
+        const fullProjDir = path.join(projectsDir, projDir);
+        const session = await getMostRecentSession(fullProjDir);
+        if (!session)
+            return;
+        sessions.push({
+            workspaceName,
+            workspacePath,
+            sessionId: session.sessionId,
+            lastActiveAt: session.lastActiveAt,
+            lastActiveLabel: relativeTime(session.lastActiveAt),
+            agentType,
+        });
+    }));
+    // Sort by most recently active first
+    sessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
+    return sessions;
+}
+/** @internal exported for testing */
+function pathToProjectDirName(absPath, agentType = 'claude') {
+    if (agentType === 'pi') {
+        // Pi format: --Users-yotambloom-Work-workspaces-- (leading --, single - between segments, trailing --)
+        // Strip leading /, then replace remaining / with -
+        const inner = absPath.replace(/^\//, '').replace(/\//g, '-');
+        return '--' + inner + '--';
+    }
+    // Claude format: -Users-yotambloom-Work-workspaces (/ replaced by -)
+    return absPath.replace(/\//g, '-');
+}
+/** @internal exported for testing */
+function extractWorkspaceName(projDir, prefix, agentType = 'claude') {
+    if (agentType === 'pi') {
+        // Pi: prefix is "--Users-...-workspaces--", dir is "--Users-...-workspaces-{name}--"
+        // The prefix ends with --, but workspace name is between prefix (minus trailing --) + - and trailing --
+        const prefixBase = prefix.slice(0, -2); // remove trailing --
+        if (!projDir.startsWith(prefixBase + '-'))
+            return null;
+        // Ensure dir is longer than just prefixBase + '--' (which would be the prefix itself)
+        if (projDir === prefix)
+            return null;
+        const rest = projDir.slice(prefixBase.length + 1); // skip the - separator
+        // rest should be "{workspace-name}--" — reject malformed dirs that don't end with --
+        if (!rest.endsWith('--'))
+            return null;
+        const name = rest.slice(0, -2);
+        return name || null;
+    }
+    // Claude: remove prefix + the separator dash
+    const rest = projDir.slice(prefix.length + 1);
+    if (!rest)
+        return null;
+    return rest;
+}
+/**
+ * Find the most recently active session in a project directory.
+ * Reads .jsonl files and checks the last line's timestamp.
+ */
+async function getMostRecentSession(projDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(projDir);
+    }
+    catch {
+        return null;
+    }
+    const jsonlFiles = entries.filter(f => f.endsWith('.jsonl'));
+    if (jsonlFiles.length === 0)
+        return null;
+    let bestSession = null;
+    // For performance, check file modification times first to find candidates
+    const fileStats = await Promise.all(jsonlFiles.map(async (f) => {
+        try {
+            const stat = await fs.stat(path.join(projDir, f));
+            return { file: f, mtime: stat.mtime };
+        }
+        catch {
+            return null;
+        }
+    }));
+    // Sort by mtime descending, only check the most recent files
+    const sorted = fileStats
+        .filter((s) => s !== null)
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    // Only read the most recent session file to get accurate timestamp
+    for (const { file, mtime } of sorted.slice(0, 1)) {
+        const sessionId = file.replace('.jsonl', '');
+        const timestamp = await getLastTimestamp(path.join(projDir, file));
+        bestSession = {
+            sessionId,
+            lastActiveAt: timestamp || mtime,
+        };
+    }
+    return bestSession;
+}
+/**
+ * Read the last few lines of a .jsonl file and extract the most recent timestamp.
+ */
+async function getLastTimestamp(filePath) {
+    try {
+        const handle = await fs.open(filePath, 'r');
+        try {
+            const stat = await handle.stat();
+            // Read last 4KB to find the last line with a timestamp
+            const readSize = Math.min(4096, stat.size);
+            const buffer = Buffer.alloc(readSize);
+            await handle.read(buffer, 0, readSize, Math.max(0, stat.size - readSize));
+            const content = buffer.toString('utf-8');
+            // Find the last line with a timestamp
+            const lines = content.split('\n').filter(l => l.trim());
+            for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                    const parsed = JSON.parse(lines[i]);
+                    if (parsed.timestamp) {
+                        return new Date(parsed.timestamp);
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/** @internal exported for testing */
+function relativeTime(date) {
+    const now = Date.now();
+    const diff = now - date.getTime();
+    const minutes = Math.floor(diff / 60000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    const months = Math.floor(days / 30);
+    return `${months}mo ago`;
+}

package/dist/utils/cleanup-operations.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitClean = exports.removeBuildArtifacts = exports.removeNodeModules = exports.calculateDirSize = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const calculateDirSize = async (dirPath) => {
+    try {
+        const { stdout } = await execAsync(`du -sk "${dirPath}"`);
+        const sizeInKB = parseInt(stdout.split('\t')[0], 10);
+        return sizeInKB;
+    }
+    catch {
+        return 0;
+    }
+};
+exports.calculateDirSize = calculateDirSize;
+const removeNodeModules = async (repoPath) => {
+    const nodeModulesPath = path.join(repoPath, 'node_modules');
+    try {
+        const sizeBefore = await (0, exports.calculateDirSize)(nodeModulesPath);
+        await fs.rm(nodeModulesPath, { recursive: true, force: true });
+        return {
+            operation: 'Remove node_modules',
+            filesRemoved: 1,
+            spaceFreed: `${(sizeBefore / 1024).toFixed(2)} MB`,
+            success: true,
+        };
+    }
+    catch (error) {
+        return {
+            operation: 'Remove node_modules',
+            filesRemoved: 0,
+            spaceFreed: '0 MB',
+            success: false,
+        };
+    }
+};
+exports.removeNodeModules = removeNodeModules;
+const removeBuildArtifacts = async (repoPath) => {
+    const artifacts = ['dist', 'build', '.next', 'coverage', 'out'];
+    let totalSize = 0;
+    let removed = 0;
+    for (const artifact of artifacts) {
+        const artifactPath = path.join(repoPath, artifact);
+        try {
+            const size = await (0, exports.calculateDirSize)(artifactPath);
+            await fs.rm(artifactPath, { recursive: true, force: true });
+            totalSize += size;
+            removed++;
+        }
+        catch {
+            // Ignore if doesn't exist
+        }
+    }
+    return {
+        operation: 'Remove build artifacts',
+        filesRemoved: removed,
+        spaceFreed: `${(totalSize / 1024).toFixed(2)} MB`,
+        success: true,
+    };
+};
+exports.removeBuildArtifacts = removeBuildArtifacts;
+const gitClean = async (repoPath, dryRun = false) => {
+    try {
+        const cmd = dryRun ? 'git clean -fdxn' : 'git clean -fdx';
+        const { stdout } = await execAsync(cmd, { cwd: repoPath });
+        const lines = stdout.split('\n').filter(l => l.trim());
+        return {
+            operation: 'Git clean',
+            filesRemoved: lines.length,
+            spaceFreed: 'Unknown',
+            success: true,
+        };
+    }
+    catch {
+        return {
+            operation: 'Git clean',
+            filesRemoved: 0,
+            spaceFreed: '0 MB',
+            success: false,
+        };
+    }
+};
+exports.gitClean = gitClean;

package/dist/utils/colors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorize = exports.colors = void 0;
+exports.colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Foreground colors
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+    // Background colors
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+};
+const colorize = (text, color) => {
+    return `${exports.colors[color]}${text}${exports.colors.reset}`;
+};
+exports.colorize = colorize;

package/dist/utils/command-helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalOpts = getGlobalOpts;
+exports.resolveWorkspace = resolveWorkspace;
+exports.parseList = parseList;
+const workspace_meta_1 = require("./workspace-meta");
+const prompts_1 = require("./prompts");
+/**
+ * Extract global options (--force-refresh, --yes) from the root program.
+ * Commander doesn't auto-inherit parent options to subcommands,
+ * so we walk up the parent chain to find them.
+ */
+function getGlobalOpts(cmd) {
+    let root = cmd;
+    while (root.parent)
+        root = root.parent;
+    const opts = root.opts();
+    return {
+        forceRefresh: opts.forceRefresh ?? false,
+        yes: opts.yes ?? false,
+    };
+}
+/**
+ * Resolve workspace name: use provided value, or prompt interactively.
+ * In non-interactive mode (no TTY), throws if no name provided.
+ */
+async function resolveWorkspace(name) {
+    if (name)
+        return name;
+    if (!process.stdout.isTTY) {
+        throw new Error('Workspace name required in non-interactive mode. Use --workspace <name> or provide as argument.');
+    }
+    const workspaces = await (0, workspace_meta_1.listWorkspaces)();
+    if (workspaces.length === 0) {
+        throw new Error('No workspaces found. Create one first with: nemus create');
+    }
+    return (0, prompts_1.promptWorkspaceSelection)(workspaces);
+}
+/**
+ * Parse comma-separated list from a flag value.
+ */
+function parseList(value) {
+    return value.split(',').map(s => s.trim()).filter(Boolean);
+}

package/dist/utils/config.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.CLONE_MAX_BUFFER = exports.CLONE_TIMEOUT_MS = exports.CONFIG_PATH = exports.META_FILENAME = exports.SUITES_FILE = exports.HISTORY_FILE = exports.CACHE_DIR = exports.WORKSPACES_DIR = void 0;
+exports.getUserConfig = getUserConfig;
+exports.getPackageVersion = getPackageVersion;
+exports.getCloneUrl = getCloneUrl;
+exports.saveUserConfig = saveUserConfig;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const HOME_DIR = os.homedir();
+// Config file lives outside CACHE_DIR so we can read it to determine CACHE_DIR
+const CONFIG_FILE = path.join(HOME_DIR, '.workspace-manager-cache', 'config.json');
+const DEFAULTS = {
+    workspacesDir: path.join(HOME_DIR, 'workspaces'),
+    githubOrg: '',
+    autoLaunchClaude: true,
+    generateClaudeContext: true,
+    cloneProtocol: 'ssh',
+    installMcp: true,
+    aiAgent: 'auto',
+    primaryAgent: 'auto',
+    piWorkspaceInputStatus: true,
+    claudeWorkspaceStatusLine: true,
+    autoReportBugs: false,
+};
+function loadConfigFileSync() {
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        const raw = JSON.parse(content);
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return {};
+        const result = {};
+        if (typeof raw.workspacesDir === 'string' && raw.workspacesDir)
+            result.workspacesDir = raw.workspacesDir;
+        if (typeof raw.githubOrg === 'string' && raw.githubOrg)
+            result.githubOrg = raw.githubOrg;
+        if (typeof raw.autoLaunchClaude === 'boolean')
+            result.autoLaunchClaude = raw.autoLaunchClaude;
+        if (typeof raw.generateClaudeContext === 'boolean')
+            result.generateClaudeContext = raw.generateClaudeContext;
+        if (raw.cloneProtocol === 'ssh' || raw.cloneProtocol === 'https')
+            result.cloneProtocol = raw.cloneProtocol;
+        if (typeof raw.installMcp === 'boolean')
+            result.installMcp = raw.installMcp;
+        const agentValues = ['claude', 'pi', 'opencode', 'codex', 'gemini'];
+        if (agentValues.includes(raw.aiAgent) || raw.aiAgent === 'both' || raw.aiAgent === 'auto')
+            result.aiAgent = raw.aiAgent;
+        if (agentValues.includes(raw.primaryAgent) || raw.primaryAgent === 'auto')
+            result.primaryAgent = raw.primaryAgent;
+        if (typeof raw.piWorkspaceInputStatus === 'boolean')
+            result.piWorkspaceInputStatus = raw.piWorkspaceInputStatus;
+        if (typeof raw.claudeWorkspaceStatusLine === 'boolean')
+            result.claudeWorkspaceStatusLine = raw.claudeWorkspaceStatusLine;
+        if (typeof raw.autoReportBugs === 'boolean')
+            result.autoReportBugs = raw.autoReportBugs;
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+/** Get the full resolved user config (defaults + file overrides). Always reads from disk. */
+function getUserConfig() {
+    return { ...DEFAULTS, ...loadConfigFileSync() };
+}
+// Bootstrap constants from initial config read (env vars take precedence)
+const initialConfig = getUserConfig();
+exports.WORKSPACES_DIR = process.env.WORKSPACE_MANAGER_DIR || initialConfig.workspacesDir;
+exports.CACHE_DIR = process.env.WORKSPACE_MANAGER_CACHE_DIR || path.join(HOME_DIR, '.workspace-manager-cache');
+exports.HISTORY_FILE = path.join(exports.CACHE_DIR, 'history.jsonl');
+exports.SUITES_FILE = path.join(exports.CACHE_DIR, 'suites.json');
+exports.META_FILENAME = '.workspace-meta.json';
+exports.CONFIG_PATH = CONFIG_FILE;
+// ── Clone execution limits ──────────────────────────────────────────────────
+// Git clone runs via child_process.exec, which (a) kills the process on
+// timeout and (b) has a small default maxBuffer (1 MB) that a large repo's
+// progress output can blow past. Both surface as confusing "Command failed"
+// errors, so we set generous, overridable limits here.
+exports.CLONE_TIMEOUT_MS = (() => {
+    const parsed = Number(process.env.WORKSPACE_CLONE_TIMEOUT_MS);
+    // Invalid or non-positive values (incl. 0) fall back to the 15-min default.
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 15 * 60 * 1000;
+})();
+exports.CLONE_MAX_BUFFER = 64 * 1024 * 1024; // 64 MB
+exports.config = {
+    workspacesDir: exports.WORKSPACES_DIR,
+    cacheDir: exports.CACHE_DIR,
+    historyFile: exports.HISTORY_FILE,
+    suitesFile: exports.SUITES_FILE,
+    metaFilename: exports.META_FILENAME,
+};
+/** Read the package version from package.json. */
+function getPackageVersion() {
+    try {
+        const pkgPath = path.join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Get the clone URL for a repo based on the configured protocol. */
+function getCloneUrl(repo) {
+    const { cloneProtocol } = getUserConfig();
+    if (cloneProtocol === 'https') {
+        return repo.url.endsWith('.git') ? repo.url : `${repo.url}.git`;
+    }
+    return repo.sshUrl;
+}
+/** Save user config to disk. */
+function saveUserConfig(cfg) {
+    const dir = path.dirname(CONFIG_FILE);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+}

package/dist/utils/context-file.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Shared utilities for CONTEXT.md file formatting.
+ * Used by both the CLI (save-context command) and MCP tool (handleSaveContext).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatContextFile = formatContextFile;
+exports.appendToContextFile = appendToContextFile;
+/**
+ * Format a fresh CONTEXT.md file with header and body.
+ */
+function formatContextFile(workspaceName, body, timestamp) {
+    const ts = timestamp || new Date().toISOString().replace('T', ' ').replace(/\.\d+Z$/, 'Z');
+    return `# Workspace Context: ${workspaceName}
+
+> This file contains saved progress and context for AI agents.
+> It persists across \`/clear\` and session restarts.
+> Last updated: ${ts}
+
+${body}
+`;
+}
+/**
+ * Append content to an existing CONTEXT.md, adding a timestamped separator.
+ * If the existing file can't be read, returns a fresh formatted file.
+ */
+function appendToContextFile(existingContent, workspaceName, newContent, timestamp) {
+    const ts = timestamp || new Date().toISOString().replace('T', ' ').replace(/\.\d+Z$/, 'Z');
+    if (existingContent) {
+        return existingContent.trimEnd() + `\n\n---\n\n### Update (${ts})\n\n${newContent}`;
+    }
+    return formatContextFile(workspaceName, newContent, ts);
+}