@nemus-cli/nemus 0.2.1

package/src/types/ink.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Type declarations for ink v5 (ESM package used via dynamic import).
+ * Provides basic types for the components and hooks we use.
+ * Full types live in node_modules/ink/build/index.d.ts but can't be
+ * resolved with moduleResolution: "node".
+ */
+
+declare module 'ink' {
+  import { FC, ReactNode, Key as ReactKey } from 'react';
+
+  // Render
+  export interface Instance {
+    rerender: (tree: ReactNode) => void;
+    unmount: () => void;
+    waitUntilExit: () => Promise<void>;
+    cleanup: () => void;
+    clear: () => void;
+  }
+
+  export interface RenderOptions {
+    stdout?: NodeJS.WriteStream;
+    stdin?: NodeJS.ReadStream;
+    stderr?: NodeJS.WriteStream;
+    debug?: boolean;
+    exitOnCtrlC?: boolean;
+    patchConsole?: boolean;
+  }
+
+  export function render(tree: ReactNode, options?: RenderOptions): Instance;
+
+  // Components
+  export interface BoxProps {
+    children?: ReactNode;
+    flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    flexGrow?: number;
+    flexShrink?: number;
+    flexBasis?: number | string;
+    alignItems?: 'flex-start' | 'center' | 'flex-end' | 'stretch';
+    alignSelf?: 'auto' | 'flex-start' | 'center' | 'flex-end' | 'stretch';
+    justifyContent?: 'flex-start' | 'center' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly';
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number;
+    minHeight?: number;
+    padding?: number;
+    paddingX?: number;
+    paddingY?: number;
+    paddingTop?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    paddingRight?: number;
+    margin?: number;
+    marginX?: number;
+    marginY?: number;
+    marginTop?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    marginRight?: number;
+    gap?: number;
+    columnGap?: number;
+    rowGap?: number;
+    borderStyle?: 'single' | 'double' | 'round' | 'bold' | 'singleDouble' | 'doubleSingle' | 'classic' | 'arrow';
+    borderColor?: string;
+    borderTop?: boolean;
+    borderBottom?: boolean;
+    borderLeft?: boolean;
+    borderRight?: boolean;
+    borderDimColor?: boolean;
+    display?: 'flex' | 'none';
+    overflow?: 'visible' | 'hidden';
+  }
+
+  export const Box: FC<BoxProps>;
+
+  export interface TextProps {
+    children?: ReactNode;
+    color?: string;
+    backgroundColor?: string;
+    dimColor?: boolean;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    inverse?: boolean;
+    wrap?: 'wrap' | 'truncate' | 'truncate-start' | 'truncate-middle' | 'truncate-end';
+  }
+
+  export const Text: FC<TextProps>;
+
+  export const Newline: FC<{ count?: number }>;
+  export const Spacer: FC;
+
+  export interface StaticProps<T> {
+    items: T[];
+    children: (item: T, index: number) => ReactNode;
+    style?: BoxProps;
+  }
+  export function Static<T>(props: StaticProps<T>): ReactNode;
+
+  export interface TransformProps {
+    children?: ReactNode;
+    transform: (children: string, index: number) => string;
+  }
+  export const Transform: FC<TransformProps>;
+
+  // Hooks
+  export interface Key {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    pageDown: boolean;
+    pageUp: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    shift: boolean;
+    tab: boolean;
+    backspace: boolean;
+    delete: boolean;
+    meta: boolean;
+  }
+
+  export function useInput(
+    inputHandler: (input: string, key: Key) => void,
+    options?: { isActive?: boolean }
+  ): void;
+
+  export function useApp(): { exit: (error?: Error) => void };
+  export function useStdin(): { stdin: NodeJS.ReadStream; isRawModeSupported: boolean; setRawMode: (mode: boolean) => void };
+  export function useStdout(): { stdout: NodeJS.WriteStream; write: (data: string) => void };
+  export function useStderr(): { stderr: NodeJS.WriteStream; write: (data: string) => void };
+  export function useFocus(options?: { autoFocus?: boolean; isActive?: boolean; id?: string }): { isFocused: boolean };
+  export function useFocusManager(): { focusNext: () => void; focusPrevious: () => void; focus: (id: string) => void; enableFocus: () => void; disableFocus: () => void };
+  export function measureElement(ref: { current: any }): { width: number; height: number };
+}
+
+declare module 'ink-select-input' {
+  import { FC } from 'react';
+
+  export interface Item<V> {
+    key?: string;
+    label: string;
+    value: V;
+  }
+
+  export interface Props<V> {
+    items?: Array<Item<V>>;
+    isFocused?: boolean;
+    initialIndex?: number;
+    limit?: number;
+    indicatorComponent?: FC<{ isSelected: boolean }>;
+    itemComponent?: FC<{ isSelected: boolean; label: string }>;
+    onSelect?: (item: Item<V>) => void;
+    onHighlight?: (item: Item<V>) => void;
+  }
+
+  function SelectInput<V>(props: Props<V>): JSX.Element;
+  export default SelectInput;
+}
+
+declare module 'ink-spinner' {
+  import { FC } from 'react';
+
+  export interface Props {
+    type?: string;
+  }
+
+  const Spinner: FC<Props>;
+  export default Spinner;
+}

package/src/utils/agent-config.test.ts

@@ -0,0 +1,303 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// Mock os.homedir so agent-config computes paths relative to our temp dir
+vi.mock('os', async () => {
+  const actual = await vi.importActual<typeof import('os')>('os');
+  return { ...actual, homedir: vi.fn(actual.homedir) };
+});
+
+// Mock child_process for CLI availability checks
+vi.mock('child_process', async () => {
+  const actual = await vi.importActual<typeof import('child_process')>('child_process');
+  return { ...actual, execSync: vi.fn(actual.execSync) };
+});
+
+const execSync = vi.mocked(await import('child_process')).execSync;
+
+describe('agent-config', () => {
+  let tempDir: string;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-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();
+  });
+
+  function writeConfig(cfg: Record<string, unknown>) {
+    const cacheDir = path.join(tempDir, '.workspace-manager-cache');
+    fs.writeFileSync(path.join(cacheDir, 'config.json'), JSON.stringify(cfg));
+  }
+
+  async function loadModule() {
+    // Default mock: only claude and pi CLIs are available
+    // Tests that need all agents or specific availability override this before/after calling loadModule
+    execSync.mockImplementation((cmd: string) => {
+      if (cmd.toString().includes('claude --version')) return Buffer.from('1.0.0');
+      if (cmd.toString().includes('pi --version')) return Buffer.from('1.0.0');
+      throw new Error('not found');
+    });
+    const mod = await import('./agent-config');
+    // Reset caches to ensure clean state for each test
+    mod.resetAgentConfigCache();
+    return mod;
+  }
+
+  describe('getAgentPaths', () => {
+    it('returns Claude paths for "claude"', async () => {
+      const { getAgentPaths } = await loadModule();
+      const paths = getAgentPaths('claude');
+      expect(paths.type).toBe('claude');
+      expect(paths.skillsDir).toContain('.claude');
+      expect(paths.skillsDir).toContain('skills');
+      expect(paths.contextFileName).toBe('CLAUDE.md');
+      expect(paths.launchCommand).toBe('claude');
+      expect(paths.supportsMcp).toBe(true);
+      expect(paths.supportsHooks).toBe(true);
+    });
+
+    it('returns Pi paths for "pi"', async () => {
+      const { getAgentPaths } = await loadModule();
+      const paths = getAgentPaths('pi');
+      expect(paths.type).toBe('pi');
+      expect(paths.skillsDir).toContain('.pi');
+      expect(paths.skillsDir).toContain('skills');
+      expect(paths.contextFileName).toBe('AGENTS.md');
+      expect(paths.launchCommand).toBe('pi');
+      expect(paths.supportsMcp).toBe(false);
+      expect(paths.supportsHooks).toBe(false);
+    });
+  });
+
+  describe('getActiveAgents', () => {
+    it('returns only Claude when aiAgent is "claude"', async () => {
+      writeConfig({ aiAgent: 'claude' });
+      const { getActiveAgents } = await loadModule();
+      const agents = getActiveAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].type).toBe('claude');
+    });
+
+    it('returns only Pi when aiAgent is "pi"', async () => {
+      writeConfig({ aiAgent: 'pi' });
+      const { getActiveAgents } = await loadModule();
+      const agents = getActiveAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].type).toBe('pi');
+    });
+
+    it('returns all available agents when aiAgent is "both"', async () => {
+      writeConfig({ aiAgent: 'both' });
+      // Mock all CLIs as available
+      execSync.mockImplementation(() => Buffer.from('1.0.0'));
+      const { getActiveAgents, resetAgentConfigCache } = await import('./agent-config');
+      resetAgentConfigCache();
+      const agents = getActiveAgents();
+      expect(agents).toHaveLength(5);
+      expect(agents.map(a => a.type)).toEqual(['claude', 'pi', 'opencode', 'codex', 'gemini']);
+    });
+
+    it('resolves auto to claude when only claude CLI available', async () => {
+      writeConfig({ aiAgent: 'auto' });
+      execSync.mockImplementation((cmd: string) => {
+        if (cmd.toString().includes('claude --version')) return Buffer.from('1.0.0');
+        throw new Error('not found');
+      });
+      const { getActiveAgents, resetAgentConfigCache } = await import('./agent-config');
+      resetAgentConfigCache();
+      const agents = getActiveAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].type).toBe('claude');
+    });
+
+    it('resolves auto to pi when only pi CLI available', async () => {
+      writeConfig({ aiAgent: 'auto' });
+      execSync.mockImplementation((cmd: string) => {
+        if (cmd.toString().includes('pi --version')) return Buffer.from('1.0.0');
+        throw new Error('not found');
+      });
+      const { getActiveAgents, resetAgentConfigCache } = await import('./agent-config');
+      resetAgentConfigCache();
+      const agents = getActiveAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].type).toBe('pi');
+    });
+
+    it('resolves auto to both when both CLIs available', async () => {
+      writeConfig({ aiAgent: 'auto' });
+      execSync.mockImplementation(() => Buffer.from('1.0.0'));
+      const { getActiveAgents, resetAgentConfigCache } = await import('./agent-config');
+      resetAgentConfigCache();
+      const agents = getActiveAgents();
+      expect(agents).toHaveLength(5);
+      expect(agents.map(a => a.type)).toContain('claude');
+      expect(agents.map(a => a.type)).toContain('pi');
+      expect(agents.map(a => a.type)).toContain('opencode');
+    });
+  });
+
+  describe('getPrimaryAgent', () => {
+    it('returns Claude when primaryAgent is "claude"', async () => {
+      writeConfig({ primaryAgent: 'claude' });
+      const { getPrimaryAgent } = await loadModule();
+      expect(getPrimaryAgent().type).toBe('claude');
+    });
+
+    it('returns Pi when primaryAgent is "pi"', async () => {
+      writeConfig({ primaryAgent: 'pi' });
+      const { getPrimaryAgent } = await loadModule();
+      expect(getPrimaryAgent().type).toBe('pi');
+    });
+
+    it('returns an agent when primaryAgent is "auto" (default)', async () => {
+      writeConfig({});
+      const { getPrimaryAgent } = await loadModule();
+      // auto detects installed CLIs — just verify it returns something
+      const agent = getPrimaryAgent();
+      expect(['claude', 'pi']).toContain(agent.type);
+    });
+  });
+
+  describe('getSkillsTargetDirs', () => {
+    it('returns one dir for single agent', async () => {
+      writeConfig({ aiAgent: 'claude' });
+      const { getSkillsTargetDirs } = await loadModule();
+      const dirs = getSkillsTargetDirs();
+      expect(dirs).toHaveLength(1);
+      expect(dirs[0]).toContain('.claude');
+    });
+
+    it('returns two dirs for both agents', async () => {
+      writeConfig({ aiAgent: 'both' });
+      const { getSkillsTargetDirs } = await loadModule();
+      const dirs = getSkillsTargetDirs();
+      expect(dirs).toHaveLength(2);
+      expect(dirs[0]).toContain('.claude');
+      expect(dirs[1]).toContain('.pi');
+    });
+
+    it('returns Pi dir only for pi agent', async () => {
+      writeConfig({ aiAgent: 'pi' });
+      const { getSkillsTargetDirs } = await loadModule();
+      const dirs = getSkillsTargetDirs();
+      expect(dirs).toHaveLength(1);
+      expect(dirs[0]).toContain('.pi');
+    });
+  });
+
+  describe('getContextFileNames', () => {
+    it('returns CLAUDE.md for Claude', async () => {
+      writeConfig({ aiAgent: 'claude' });
+      const { getContextFileNames } = await loadModule();
+      expect(getContextFileNames()).toEqual(['CLAUDE.md']);
+    });
+
+    it('returns AGENTS.md for Pi', async () => {
+      writeConfig({ aiAgent: 'pi' });
+      const { getContextFileNames } = await loadModule();
+      expect(getContextFileNames()).toEqual(['AGENTS.md']);
+    });
+
+    it('returns both file names for both agents', async () => {
+      writeConfig({ aiAgent: 'both' });
+      const { getContextFileNames } = await loadModule();
+      const names = getContextFileNames();
+      expect(names).toContain('CLAUDE.md');
+      expect(names).toContain('AGENTS.md');
+      expect(names).toHaveLength(2);
+    });
+  });
+
+  describe('getAllKnownContextFileNames', () => {
+    it('lists AGENTS.md before CLAUDE.md (per-repo scan priority)', async () => {
+      // findContextFilesInDir embeds the FIRST existing candidate per dir.
+      // In dual-agent repos CLAUDE.md is often a thin "@AGENTS.md" shim, so
+      // AGENTS.md must win to embed the real content, not the pointer.
+      const { getAllKnownContextFileNames } = await loadModule();
+      const names = getAllKnownContextFileNames();
+      expect(names.indexOf('AGENTS.md')).toBeLessThan(names.indexOf('CLAUDE.md'));
+    });
+
+    it('still recognizes legacy .claude.md (kept last)', async () => {
+      const { getAllKnownContextFileNames } = await loadModule();
+      const names = getAllKnownContextFileNames();
+      expect(names).toContain('.claude.md');
+      expect(names.indexOf('.claude.md')).toBe(names.length - 1);
+    });
+  });
+
+  describe('getHookTargetFiles', () => {
+    it('returns Claude settings for Claude agent', async () => {
+      writeConfig({ aiAgent: 'claude' });
+      const { getHookTargetFiles } = await loadModule();
+      const files = getHookTargetFiles();
+      expect(files).toHaveLength(1);
+      expect(files[0]).toContain('.claude');
+    });
+
+    it('returns empty for Pi-only (Pi does not support hooks)', async () => {
+      writeConfig({ aiAgent: 'pi' });
+      const { getHookTargetFiles } = await loadModule();
+      expect(getHookTargetFiles()).toHaveLength(0);
+    });
+
+    it('returns only Claude settings for both (Pi has no hooks)', async () => {
+      writeConfig({ aiAgent: 'both' });
+      const { getHookTargetFiles } = await loadModule();
+      const files = getHookTargetFiles();
+      expect(files).toHaveLength(1);
+      expect(files[0]).toContain('.claude');
+    });
+  });
+
+  describe('getMcpAgents', () => {
+    it('returns Claude for "claude" config', async () => {
+      writeConfig({ aiAgent: 'claude' });
+      const { getMcpAgents } = await loadModule();
+      const agents = getMcpAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].type).toBe('claude');
+    });
+
+    it('returns empty for Pi-only (Pi has no MCP)', async () => {
+      writeConfig({ aiAgent: 'pi' });
+      const { getMcpAgents } = await loadModule();
+      expect(getMcpAgents()).toHaveLength(0);
+    });
+
+    it('returns only Claude for both (Pi has no MCP)', async () => {
+      writeConfig({ aiAgent: 'both' });
+      const { getMcpAgents } = await loadModule();
+      const agents = getMcpAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].type).toBe('claude');
+    });
+  });
+
+  describe('resumeCommand', () => {
+    it('generates correct Claude resume command', async () => {
+      const { getAgentPaths } = await loadModule();
+      const claude = getAgentPaths('claude');
+      expect(claude.resumeCommand('abc-123')).toBe('claude --resume abc-123 --fork-session');
+    });
+
+    it('generates correct Pi resume command', async () => {
+      const { getAgentPaths } = await loadModule();
+      const pi = getAgentPaths('pi');
+      expect(pi.resumeCommand('abc-123')).toBe('pi --session abc-123 --fork');
+    });
+  });
+});