@nemus-cli/nemus 0.2.1

package/src/utils/config.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+vi.mock('os', async () => {
+  const actual = await vi.importActual<typeof import('os')>('os');
+  return { ...actual, homedir: vi.fn(actual.homedir) };
+});
+
+describe('config', () => {
+  let tempDir: string;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-config-test-'));
+    const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+    fs.mkdirSync(cacheDir, { recursive: true });
+    process.env.WORKSPACE_MANAGER_DIR = path.join(tempDir, 'workspaces');
+    process.env.WORKSPACE_MANAGER_CACHE_DIR = cacheDir;
+    vi.mocked(os.homedir).mockReturnValue(tempDir);
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  async function loadModule() {
+    return await import('./config');
+  }
+
+  describe('getCloneUrl', () => {
+    it('returns sshUrl by default (ssh protocol)', async () => {
+      const { getCloneUrl } = await loadModule();
+      const repo = { url: 'https://github.com/acme/my-repo', sshUrl: 'git@github.com:acme/my-repo.git' };
+      expect(getCloneUrl(repo)).toBe('git@github.com:acme/my-repo.git');
+    });
+
+    it('returns https url with .git suffix when protocol is https', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ cloneProtocol: 'https' })
+      );
+
+      const { getCloneUrl } = await loadModule();
+      const repo = { url: 'https://github.com/acme/my-repo', sshUrl: 'git@github.com:acme/my-repo.git' };
+      expect(getCloneUrl(repo)).toBe('https://github.com/acme/my-repo.git');
+    });
+
+    it('does not double-append .git', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ cloneProtocol: 'https' })
+      );
+
+      const { getCloneUrl } = await loadModule();
+      const repo = { url: 'https://github.com/acme/my-repo.git', sshUrl: 'git@github.com:acme/my-repo.git' };
+      expect(getCloneUrl(repo)).toBe('https://github.com/acme/my-repo.git');
+    });
+  });
+
+  describe('getPackageVersion', () => {
+    it('returns a semver-like string', async () => {
+      const { getPackageVersion } = await loadModule();
+      const version = getPackageVersion();
+      expect(version).toMatch(/^\d+\.\d+\.\d+/);
+    });
+  });
+
+  describe('getUserConfig', () => {
+    it('returns defaults when no config file exists', async () => {
+      const { getUserConfig } = await loadModule();
+      const cfg = getUserConfig();
+      expect(cfg.githubOrg).toBe('');
+      expect(cfg.cloneProtocol).toBe('ssh');
+      expect(cfg.autoLaunchClaude).toBe(true);
+      expect(cfg.generateClaudeContext).toBe(true);
+      expect(cfg.installMcp).toBe(true);
+      expect(cfg.aiAgent).toBe('auto');
+      expect(cfg.primaryAgent).toBe('auto');
+    });
+
+    it('reads fresh values from disk on each call', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ githubOrg: 'org-a' })
+      );
+
+      const { getUserConfig } = await loadModule();
+      expect(getUserConfig().githubOrg).toBe('org-a');
+
+      // Update config on disk
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ githubOrg: 'org-b' })
+      );
+
+      // Should see the new value without re-importing
+      expect(getUserConfig().githubOrg).toBe('org-b');
+    });
+
+    it('ignores invalid field types from config file', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({
+          githubOrg: 123,
+          cloneProtocol: 'ftp',
+          autoLaunchClaude: 'yes',
+          workspacesDir: null,
+          installMcp: 'true',
+          aiAgent: 'invalid',
+        })
+      );
+
+      const { getUserConfig } = await loadModule();
+      const cfg = getUserConfig();
+      // All invalid values should be ignored, defaults used
+      expect(cfg.githubOrg).toBe('');
+      expect(cfg.cloneProtocol).toBe('ssh');
+      expect(cfg.autoLaunchClaude).toBe(true);
+      expect(cfg.workspacesDir).toContain('workspaces');
+      expect(cfg.installMcp).toBe(true);
+      expect(cfg.aiAgent).toBe('auto');
+    });
+  });
+
+  describe('saveUserConfig', () => {
+    it('writes config to disk and can be read back', async () => {
+      const { saveUserConfig, getUserConfig } = await loadModule();
+
+      saveUserConfig({
+        workspacesDir: '/custom/path',
+        githubOrg: 'test-org',
+        autoLaunchClaude: false,
+        generateClaudeContext: false,
+        cloneProtocol: 'https',
+        installMcp: false,
+        aiAgent: 'pi',
+        primaryAgent: 'pi',
+      });
+
+      const cfg = getUserConfig();
+      expect(cfg.githubOrg).toBe('test-org');
+      expect(cfg.cloneProtocol).toBe('https');
+      expect(cfg.autoLaunchClaude).toBe(false);
+      expect(cfg.aiAgent).toBe('pi');
+      expect(cfg.primaryAgent).toBe('pi');
+    });
+  });
+
+  describe('aiAgent config', () => {
+    it('reads aiAgent "claude" from config file', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ aiAgent: 'claude' })
+      );
+
+      const { getUserConfig } = await loadModule();
+      expect(getUserConfig().aiAgent).toBe('claude');
+    });
+
+    it('reads aiAgent "pi" from config file', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ aiAgent: 'pi' })
+      );
+
+      const { getUserConfig } = await loadModule();
+      expect(getUserConfig().aiAgent).toBe('pi');
+    });
+
+    it('reads aiAgent "both" from config file', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ aiAgent: 'both' })
+      );
+
+      const { getUserConfig } = await loadModule();
+      expect(getUserConfig().aiAgent).toBe('both');
+    });
+
+    it('ignores invalid aiAgent values', async () => {
+      const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+      fs.writeFileSync(
+        path.join(cacheDir, 'config.json'),
+        JSON.stringify({ aiAgent: 'copilot' })
+      );
+
+      const { getUserConfig } = await loadModule();
+      expect(getUserConfig().aiAgent).toBe('auto');
+    });
+  });
+});

package/src/utils/config.ts

@@ -0,0 +1,133 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from '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');
+
+/** Coding-agent CLIs Nemus can integrate with. */
+export type ConcreteAgentType = 'claude' | 'pi' | 'opencode' | 'codex' | 'gemini';
+export type AgentType = ConcreteAgentType | 'both' | 'auto';
+export type PrimaryAgentType = ConcreteAgentType | 'auto';
+
+export interface UserConfig {
+  workspacesDir: string;
+  githubOrg: string;
+  autoLaunchClaude: boolean;
+  generateClaudeContext: boolean;
+  cloneProtocol: 'ssh' | 'https';
+  installMcp: boolean;
+  /** Which AI agent(s) to integrate with: 'claude', 'pi', 'both', or 'auto' (detect from installed CLIs) */
+  aiAgent: AgentType;
+  /** Which agent to launch when opening workspaces: 'claude', 'pi', or 'auto' (first available) */
+  primaryAgent: PrimaryAgentType;
+  /** Show workspace status widget in Pi's input area (branch, PRs, CI). Pi only. */
+  piWorkspaceInputStatus: boolean;
+  /** Show workspace repo table in Claude Code's status line. Claude only. */
+  claudeWorkspaceStatusLine: boolean;
+  /** Automatically file a GitHub issue when a command crashes (deduped, sanitized). */
+  autoReportBugs: boolean;
+}
+
+const DEFAULTS: UserConfig = {
+  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(): Partial<UserConfig> {
+  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: Partial<UserConfig> = {};
+    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. */
+export function getUserConfig(): UserConfig {
+  return { ...DEFAULTS, ...loadConfigFileSync() };
+}
+
+// Bootstrap constants from initial config read (env vars take precedence)
+const initialConfig = getUserConfig();
+
+export const WORKSPACES_DIR = process.env.WORKSPACE_MANAGER_DIR || initialConfig.workspacesDir;
+export const CACHE_DIR = process.env.WORKSPACE_MANAGER_CACHE_DIR || path.join(HOME_DIR, '.workspace-manager-cache');
+export const HISTORY_FILE = path.join(CACHE_DIR, 'history.jsonl');
+export const SUITES_FILE = path.join(CACHE_DIR, 'suites.json');
+export const META_FILENAME = '.workspace-meta.json';
+export const 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.
+export const 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;
+})();
+export const CLONE_MAX_BUFFER = 64 * 1024 * 1024; // 64 MB
+
+export const config = {
+  workspacesDir: WORKSPACES_DIR,
+  cacheDir: CACHE_DIR,
+  historyFile: HISTORY_FILE,
+  suitesFile: SUITES_FILE,
+  metaFilename: META_FILENAME,
+};
+
+/** Read the package version from package.json. */
+export function getPackageVersion(): string {
+  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. */
+export function getCloneUrl(repo: { url: string; sshUrl: string }): string {
+  const { cloneProtocol } = getUserConfig();
+  if (cloneProtocol === 'https') {
+    return repo.url.endsWith('.git') ? repo.url : `${repo.url}.git`;
+  }
+  return repo.sshUrl;
+}
+
+/** Save user config to disk. */
+export function saveUserConfig(cfg: UserConfig): void {
+  const dir = path.dirname(CONFIG_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+}

package/src/utils/context-file.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared utilities for CONTEXT.md file formatting.
+ * Used by both the CLI (save-context command) and MCP tool (handleSaveContext).
+ */
+
+/**
+ * Format a fresh CONTEXT.md file with header and body.
+ */
+export function formatContextFile(workspaceName: string, body: string, timestamp?: string): string {
+  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.
+ */
+export function appendToContextFile(
+  existingContent: string | null,
+  workspaceName: string,
+  newContent: string,
+  timestamp?: string
+): string {
+  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);
+}

package/src/utils/dashboard-hooks.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { HOOK_MARKER } from '../types/dashboard';
+
+let tmpDir: string;
+let settingsPath: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
+  settingsPath = path.join(tmpDir, '.claude', 'settings.json');
+  fs.mkdirSync(path.join(tmpDir, '.claude'), { recursive: true });
+  // Reset module cache so each test gets a fresh import
+  vi.resetModules();
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+function writeSettings(content: any) {
+  fs.writeFileSync(settingsPath, JSON.stringify(content, null, 2), 'utf-8');
+}
+
+function readSettings(): any {
+  return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+}
+
+async function importModule() {
+  // Mock os.homedir to return our temp dir before importing the module
+  vi.doMock('os', () => ({
+    ...os,
+    homedir: () => tmpDir,
+  }));
+  return await import('./dashboard-hooks');
+}
+
+describe('dashboard-hooks', () => {
+  it('installDashboardHooks into empty settings', async () => {
+    writeSettings({});
+    const { installDashboardHooks } = await importModule();
+    installDashboardHooks();
+
+    const settings = readSettings();
+    expect(settings.hooks).toBeDefined();
+    expect(settings.hooks.SessionStart).toBeDefined();
+    expect(settings.hooks.PreToolUse).toBeDefined();
+    expect(settings.hooks.PostToolUse).toBeDefined();
+    expect(settings.hooks.UserPromptSubmit).toBeDefined();
+    expect(settings.hooks.Notification).toBeDefined();
+    expect(settings.hooks.Stop).toBeDefined();
+    expect(settings.hooks.SessionEnd).toBeDefined();
+
+    // Each should have exactly one group with our marker
+    for (const event of ['SessionStart', 'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Notification', 'Stop', 'SessionEnd']) {
+      const groups = settings.hooks[event];
+      expect(groups.length).toBeGreaterThanOrEqual(1);
+      const ourGroup = groups.find((g: any) =>
+        g.hooks.some((h: any) => h.command?.includes(HOOK_MARKER))
+      );
+      expect(ourGroup).toBeDefined();
+    }
+  });
+
+  it('installDashboardHooks preserves existing hooks', async () => {
+    writeSettings({
+      hooks: {
+        Notification: [
+          { hooks: [{ type: 'command', command: 'echo existing-notification' }] }
+        ],
+        Stop: [
+          { hooks: [{ type: 'command', command: 'echo existing-stop' }] }
+        ],
+      },
+    });
+
+    const { installDashboardHooks } = await importModule();
+    installDashboardHooks();
+
+    const settings = readSettings();
+
+    // Existing hooks should still be there
+    expect(settings.hooks.Notification[0].hooks[0].command).toBe('echo existing-notification');
+    expect(settings.hooks.Stop[0].hooks[0].command).toBe('echo existing-stop');
+
+    // Our hooks should be appended
+    expect(settings.hooks.Notification.length).toBe(2);
+    expect(settings.hooks.Stop.length).toBe(2);
+  });
+
+  it('installDashboardHooks is idempotent', async () => {
+    writeSettings({});
+    const { installDashboardHooks } = await importModule();
+
+    installDashboardHooks();
+    const firstInstall = readSettings();
+
+    installDashboardHooks();
+    const secondInstall = readSettings();
+
+    // Should have same number of hook groups
+    for (const event of ['SessionStart', 'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Notification', 'Stop', 'SessionEnd']) {
+      expect(secondInstall.hooks[event].length).toBe(firstInstall.hooks[event].length);
+    }
+  });
+
+  it('areDashboardHooksInstalled returns false when not installed', async () => {
+    writeSettings({});
+    const { areDashboardHooksInstalled } = await importModule();
+    expect(areDashboardHooksInstalled()).toBe(false);
+  });
+
+  it('areDashboardHooksInstalled returns true after install', async () => {
+    writeSettings({});
+    const { installDashboardHooks, areDashboardHooksInstalled } = await importModule();
+    installDashboardHooks();
+    expect(areDashboardHooksInstalled()).toBe(true);
+  });
+
+  it('uninstallDashboardHooks removes only our hooks', async () => {
+    writeSettings({
+      hooks: {
+        Notification: [
+          { hooks: [{ type: 'command', command: 'echo keep-this' }] },
+          { hooks: [{ type: 'command', command: `node /path/handler --marker ${HOOK_MARKER}` }] },
+        ],
+      },
+    });
+
+    const { uninstallDashboardHooks } = await importModule();
+    uninstallDashboardHooks();
+
+    const settings = readSettings();
+    expect(settings.hooks.Notification.length).toBe(1);
+    expect(settings.hooks.Notification[0].hooks[0].command).toBe('echo keep-this');
+  });
+
+  it('uninstallDashboardHooks handles missing settings gracefully', async () => {
+    // No settings file — should not throw
+    const { uninstallDashboardHooks } = await importModule();
+    expect(() => uninstallDashboardHooks()).not.toThrow();
+  });
+
+  it('settings file created when missing', async () => {
+    // Ensure no settings file exists
+    try { fs.unlinkSync(settingsPath); } catch { /* fine */ }
+
+    const { installDashboardHooks } = await importModule();
+    installDashboardHooks();
+
+    expect(fs.existsSync(settingsPath)).toBe(true);
+  });
+
+  it('PreToolUse hook has empty matcher', async () => {
+    writeSettings({});
+    const { installDashboardHooks } = await importModule();
+    installDashboardHooks();
+
+    const settings = readSettings();
+    const ourGroup = settings.hooks.PreToolUse.find((g: any) =>
+      g.hooks.some((h: any) => h.command?.includes(HOOK_MARKER))
+    );
+    expect(ourGroup).toBeDefined();
+    expect(ourGroup.matcher).toBe('');
+  });
+});