@yeseh/cortex-cli 0.6.8 → 0.6.9

package/src/store/commands/init.spec.ts

@@ -1,220 +0,0 @@
-/**
- * Unit tests for the store init command handler.
- *
- * @module cli/store/commands/init.spec
- */
-
-import { describe, it, expect, afterEach, beforeEach, mock } from 'bun:test';
-import { InvalidArgumentError } from '@commander-js/extra-typings';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { PromptDeps } from '../../utils/prompts.ts';
-
-import { handleInit } from './init.ts';
-import { createMockContext, captureOutput } from '../../test-helpers.spec.ts';
-import { FilesystemConfigAdapter } from '@yeseh/cortex-storage-fs';
-
-/**
- * Creates a real FilesystemConfigAdapter backed by a temp config file and
- * injects it into a mock context so handleInit can construct a real
- * FilesystemStorageAdapter without the adapter factory throwing STORE_NOT_FOUND.
- */
-async function createInitContext(tempDir: string) {
-    const configPath = join(tempDir, 'config.yaml');
-    const configAdapter = new FilesystemConfigAdapter(configPath);
-    await configAdapter.initializeConfig();
-
-    const { ctx, stdout, stdin } = createMockContext({ cwd: tempDir });
-    // Replace the mock ConfigAdapter with a real one so FilesystemStorageAdapter
-    // construction inside handleInit works correctly.
-    (ctx as unknown as Record<string, unknown>).config = configAdapter;
-
-    return { ctx, stdout, stdin };
-}
-
-describe('handleInit', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-init-'));
-    });
-
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should initialize a store and write success message to stdout', async () => {
-        const { ctx, stdout } = await createInitContext(tempDir);
-
-        await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' });
-
-        const out = captureOutput(stdout);
-        expect(out).toContain('my-project');
-    });
-
-    it('should use the provided target path as the store path', async () => {
-        const customPath = join(tempDir, 'custom-store');
-        const { ctx, stdout } = await createInitContext(tempDir);
-
-        await handleInit(ctx, customPath, { name: 'my-project', format: 'yaml' });
-
-        const out = captureOutput(stdout);
-        expect(out).toContain('custom-store');
-    });
-
-    it('should default to .cortex under cwd when no target path is given', async () => {
-        const { ctx, stdout } = await createInitContext(tempDir);
-
-        await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' });
-
-        const out = captureOutput(stdout);
-        // Default path is <cwd>/.cortex
-        expect(out).toContain('.cortex');
-    });
-
-    it('should throw InvalidArgumentError for an invalid store name', async () => {
-        const { ctx } = await createInitContext(tempDir);
-
-        await expect(handleInit(ctx, undefined, { name: '   ', format: 'yaml' })).rejects.toThrow(
-            InvalidArgumentError,
-        );
-    });
-
-    it('should output in JSON format when format option is json', async () => {
-        const { ctx, stdout } = await createInitContext(tempDir);
-
-        await handleInit(ctx, undefined, { name: 'my-project', format: 'json' });
-
-        const out = captureOutput(stdout);
-        const parsed = JSON.parse(out) as { value: Record<string, unknown> };
-        expect(typeof parsed.value.name).toBe('string');
-        expect(typeof parsed.value.path).toBe('string');
-    });
-
-    it('should include the store name in the success output', async () => {
-        const { ctx, stdout } = await createInitContext(tempDir);
-
-        await handleInit(ctx, undefined, { name: 'hello-world', format: 'json' });
-
-        const out = captureOutput(stdout);
-        const parsed = JSON.parse(out) as { value: { name: string } };
-        expect(parsed.value.name).toBe('hello-world');
-    });
-
-    it('should expand tilde in target path', async () => {
-        const { ctx, stdout } = await createInitContext(tempDir);
-
-        // resolveUserPath expands ~ — we just verify it doesn't throw and
-        // produces output with a home-like absolute path
-        await handleInit(ctx, '~/my-store', { name: 'my-project', format: 'yaml' });
-
-        const out = captureOutput(stdout);
-        expect(out).toContain('my-store');
-    });
-
-    it('should fail when the store name already exists', async () => {
-        const { ctx } = await createInitContext(tempDir);
-        const storePath = join(tempDir, '.cortex');
-
-        await handleInit(ctx, storePath, { name: 'duplicate-store', format: 'yaml' });
-
-        // Second init with the same name should throw
-        const { ctx: ctx2 } = await createInitContext(tempDir);
-        await expect(
-            handleInit(ctx2, join(tempDir, '.cortex2'), { name: 'duplicate-store', format: 'yaml' }),
-        ).rejects.toThrow();
-    });
-});
-
-describe('handleInit - interactive mode', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-init-interactive-'));
-    });
-
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should call promptDeps.input once (path only) when stdin is a TTY and --name is explicitly given', async () => {
-        const inputMock = mock(
-            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
-        );
-        const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
-
-        const { ctx, stdin } = await createInitContext(tempDir);
-        (stdin as unknown as { isTTY: boolean }).isTTY = true;
-
-        await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' }, promptDeps);
-
-        // Should NOT call input when --name is explicitly given (skips name prompt but still prompts path)
-        // With explicit name, only path prompt is called
-        expect(inputMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('should call promptDeps.input twice (name + path) when stdin is a TTY and no --name given', async () => {
-        const inputMock = mock(
-            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
-        );
-        const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
-
-        const { ctx, stdin } = await createInitContext(tempDir);
-        (stdin as unknown as { isTTY: boolean }).isTTY = true;
-
-        // No --name provided, should prompt for both name and path
-        await handleInit(ctx, undefined, { format: 'yaml' }, promptDeps);
-
-        expect(inputMock).toHaveBeenCalledTimes(2);
-    });
-
-    it('should NOT call promptDeps.input when stdin is NOT a TTY', async () => {
-        const inputMock = mock(
-            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
-        );
-        const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
-
-        const { ctx } = await createInitContext(tempDir);
-        // ctx stdin has isTTY = undefined (non-TTY)
-
-        await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' }, promptDeps);
-
-        expect(inputMock).not.toHaveBeenCalled();
-    });
-
-    it('should skip both prompts when --name and target path are both given explicitly and TTY', async () => {
-        const inputMock = mock(
-            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
-        );
-        const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
-
-        const { ctx, stdin } = await createInitContext(tempDir);
-        (stdin as unknown as { isTTY: boolean }).isTTY = true;
-        const customPath = join(tempDir, 'custom-store');
-
-        await handleInit(ctx, customPath, { name: 'my-project', format: 'yaml' }, promptDeps);
-
-        expect(inputMock).not.toHaveBeenCalled();
-    });
-
-    it('should use prompted store name in the output', async () => {
-        const promptedName = 'prompted-store-name';
-        const inputMock = mock(
-            async ({ message, default: d }: { message: string; default?: string }) => {
-                if (message.toLowerCase().includes('name')) return promptedName;
-                return d ?? 'default-path';
-            },
-        );
-        const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
-
-        const { ctx, stdin, stdout } = await createInitContext(tempDir);
-        (stdin as unknown as { isTTY: boolean }).isTTY = true;
-
-        await handleInit(ctx, undefined, { format: 'json' }, promptDeps);
-
-        const out = captureOutput(stdout);
-        const parsed = JSON.parse(out) as { value: { name: string } };
-        expect(parsed.value.name).toBe(promptedName);
-    });
-});

package/src/store/commands/init.ts

@@ -1,272 +0,0 @@
-/**
- * Store init command for initializing a new memory store.
- *
- * This command creates a new memory store at the specified path (or current
- * directory) and registers it in the global registry. The store name is
- * either explicitly provided via --name or auto-detected from the git
- * repository name.
- *
- * @example
- * ```bash
- * # Initialize store with auto-detected name from git repo
- * cortex store init
- *
- * # Initialize store with explicit name
- * cortex store init --name my-project
- *
- * # Initialize store at a specific path
- * cortex store init ./my-store --name my-project
- *
- * # Initialize store with tilde expansion
- * cortex store init ~/memories --name personal
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { resolve } from 'node:path';
-import { stdin, stdout as processStdout } from 'node:process';
-import { resolveStoreName } from '../utils/resolve-store-name.ts';
-import { throwCliError } from '../../errors.ts';
-import { type StoreData, initializeStore } from '@yeseh/cortex-core/store';
-import { type CategoryMode, type CortexContext } from '@yeseh/cortex-core';
-import { serializeOutput, type OutputStoreInit, type OutputFormat } from '../../output.ts';
-import { resolveUserPath } from '../../utils/paths.ts';
-import { createCliConfigContext } from '../../context.ts';
-import { isTTY, defaultPromptDeps, type PromptDeps } from '../../utils/prompts.ts';
-import type { FilesystemConfigAdapter } from '@yeseh/cortex-storage-fs';
-import { FilesystemStorageAdapter } from '@yeseh/cortex-storage-fs';
-
-/**
- * Options for the init command.
- */
-export interface InitCommandOptions {
-    /** Explicit store name (otherwise auto-detected from git) */
-    name?: string;
-    /** Category mode for the store */
-    categoryMode?: CategoryMode;
-    /** Output format (yaml, json, toon) */
-    format?: string;
-    /** Optional description for the store */
-    description?: string;
-}
-
-/**
- * Writes the serialized output to the output stream.
- *
- * @param output - The store init output payload
- * @param format - The output format
- * @param stdout - The output stream
- */
-function writeOutput(
-    output: OutputStoreInit,
-    format: OutputFormat,
-    stdout: NodeJS.WritableStream,
-): void {
-    const serialized = serializeOutput({ kind: 'store-init', value: output }, format);
-    if (!serialized.ok()) {
-        throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-    }
-    stdout.write(serialized.value + '\n');
-}
-
-/**
- * Prompts the user to confirm or change the resolved store name and path.
- *
- * Prompts are selectively skipped:
- * - Name prompt skipped when `explicit.name` is provided
- * - Path prompt skipped when `explicit.path` is provided
- * - All prompts skipped when stdin is not a TTY
- *
- * @param ctx - Cortex context used for TTY detection via `ctx.stdin`
- * @param resolved - Default store name and path to present as suggestions
- * @param explicit - Which values were provided explicitly by the user
- * @param promptDeps - Injectable prompt functions for testability
- * @returns Finalized store name and path
- */
-async function promptStoreInitOptions(
-    ctx: CortexContext,
-    resolved: { storeName: string; storePath: string },
-    explicit: { name?: string; path?: string },
-    promptDeps: PromptDeps,
-): Promise<{ storeName: string; storePath: string }> {
-    if (!isTTY(ctx.stdin)) return resolved;
-
-    const storeName = explicit.name
-        ? resolved.storeName
-        : await promptDeps.input({ message: 'Store name:', default: resolved.storeName });
-
-    let storePath: string;
-    if (explicit.path) {
-        storePath = resolved.storePath;
-    }
-    else {
-        const promptedPath = await promptDeps.input({
-            message: 'Store path:',
-            default: resolved.storePath,
-        });
-        const trimmedPath = promptedPath.trim();
-        storePath = resolveUserPath(trimmedPath, process.cwd());
-    }
-
-    return { storeName, storePath };
-}
-
-/**
- * Tries to resolve the store name. Returns an empty string when resolution
- * fails and stdin is a TTY (allowing the interactive prompt to take over).
- * Re-throws when stdin is not a TTY.
- *
- * @param cwd - Current working directory for git detection
- * @param explicitName - Optional explicit name from `--name` flag
- * @param tty - Whether stdin is a TTY
- */
-async function resolveStoreNameOrEmpty(
-    cwd: string,
-    explicitName: string | undefined,
-    tty: boolean,
-): Promise<string> {
-    try {
-        return await resolveStoreName(cwd, explicitName);
-    }
-    catch (e) {
-        // When running in a TTY, only swallow errors (and fall back to prompting)
-        // if no explicit name was provided. If the user passed an explicit --name,
-        // re-throw so they see the actual invalid-name error.
-        if (tty && !explicitName) return '';
-        throw e;
-    }
-}
-
-/**
- * Handles the store init command execution.
- *
- * This function:
- * 1. Resolves the store name (explicit or git detection; falls back to empty for TTY prompt)
- * 2. Resolves target path (default to .cortex in cwd)
- * 3. When stdin is a TTY, prompts for unresolved name and/or path
- * 4. Uses `store.initialize` to create directory, index, and register
- * 5. Outputs the result
- *
- * Interactive mode activates automatically when `ctx.stdin.isTTY === true`.
- * In non-TTY environments (CI, pipes) the command behaves exactly as before —
- * no behavioral regression.
- *
- * @param ctx - The Cortex context (stdin TTY state used for interactive detection)
- * @param targetPath - Optional path for the store (defaults to .cortex in cwd)
- * @param options - Command options (name, format, categoryMode, description)
- * @param promptDeps - Injectable prompt functions; defaults to real `@inquirer/prompts` functions
- * @throws {InvalidArgumentError} When the store name is invalid
- * @throws {CommanderError} When the store already exists or init fails
- *
- * @example
- * ```typescript
- * // Explicit name + path (no prompts even in TTY):
- * await handleInit(ctx, './my-store', { name: 'my-project' });
- *
- * // Interactive (TTY detected, no --name given):
- * await handleInit(ctx, undefined, {}, defaultPromptDeps);
- * ```
- */
-export async function handleInit(
-    ctx: CortexContext,
-    targetPath: string | undefined,
-    options: InitCommandOptions = {},
-    promptDeps: PromptDeps = defaultPromptDeps,
-): Promise<void> {
-    const cwd = ctx.cwd ?? process.cwd();
-    const stdout = ctx.stdout ?? process.stdout;
-
-    const storeName = await resolveStoreNameOrEmpty(cwd, options.name, isTTY(ctx.stdin));
-
-    const storePath = targetPath
-        ? resolveUserPath(targetPath.trim(), cwd)
-        : resolve(cwd, '.cortex');
-
-    const resolved = await promptStoreInitOptions(
-        ctx,
-        { storeName, storePath },
-        { name: options.name, path: targetPath },
-        promptDeps,
-    );
-
-    const finalStoreName = resolved.storeName;
-    const finalStorePath = resolved.storePath;
-
-    if (!finalStoreName) {
-        throwCliError({
-            code: 'INVALID_STORE_NAME',
-            message: 'Store name is required. Use --name to specify one.',
-        });
-    }
-
-    const storeData: StoreData = {
-        kind: 'filesystem',
-        categoryMode: (options.categoryMode as CategoryMode) ?? 'free',
-        categories: [],
-        properties: {
-            path: finalStorePath,
-        },
-        description: options.description,
-    };
-
-    const adapter = new FilesystemStorageAdapter(ctx.config as FilesystemConfigAdapter, {
-        rootDirectory: finalStorePath,
-    });
-    const createResult = await initializeStore(adapter, finalStoreName, storeData);
-    if (!createResult.ok()) {
-        throwCliError(createResult.error);
-    }
-
-    const output: OutputStoreInit = { path: finalStorePath, name: finalStoreName };
-    const format: OutputFormat = (options.format as OutputFormat) ?? 'yaml';
-    writeOutput(output, format, stdout);
-}
-
-/**
- * The `init` subcommand for initializing a new memory store.
- *
- * Creates a new store at the specified path (or .cortex in current directory)
- * and registers it in the global registry. The store name is auto-detected
- * from the git repository name or can be explicitly provided.
- *
- * @example
- * ```bash
- * cortex store init                        # Auto-detect name from git
- * cortex store init --name my-project      # Explicit name
- * cortex store init ./store --name custom  # Custom path and name
- * ```
- */
-export const initCommand = new Command('init')
-    .description('Initialize a new memory store')
-    .argument('[path]', 'Path for the store (defaults to .cortex in current directory)')
-    .option('-n, --name <name>', 'Explicit store name (otherwise auto-detected from git)')
-    .option('-d, --description <description>', 'Optional description for the store')
-    .option('-c, --category-mode <mode>', 'Category mode (free, strict, flat)', 'free')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)', 'yaml')
-    .action(async (path, options) => {
-        const configCtx = await createCliConfigContext();
-        if (!configCtx.ok()) {
-            throwCliError(configCtx.error);
-        }
-
-        const { configAdapter, effectiveCwd } = configCtx.value;
-
-        // Build a minimal context for handleInit. The init command cannot go
-        // through the full CortexContext/adapterFactory because the store is
-        // not yet registered — the adapter factory would throw STORE_NOT_FOUND.
-        // handleInit only needs cwd, stdin, stdout, and config (to construct
-        // its own adapter directly via initializeStore).
-        const ctx = {
-            config: configAdapter,
-            cwd: effectiveCwd,
-            stdin,
-            stdout: processStdout,
-        } as unknown as CortexContext;
-
-        await handleInit(ctx, path, {
-            name: options.name,
-            description: options.description,
-            categoryMode: options.categoryMode as CategoryMode,
-            format: options.format,
-        });
-    });

package/src/store/commands/list.spec.ts

@@ -1,175 +0,0 @@
-/**
- * Unit tests for the store list command handler.
- *
- * @module cli/store/commands/list.spec
- */
-
-import { describe, it, expect } from 'bun:test';
-import { handleList } from './list.ts';
-import {
-    createMockContext,
-    captureOutput,
-} from '../../test-helpers.spec.ts';
-
-describe('handleList', () => {
-    it('should output empty store list when no stores are configured', async () => {
-        const { ctx, stdout } = createMockContext({ stores: {} });
-
-        await handleList(ctx, {}, { stdout });
-
-        const output = captureOutput(stdout);
-        // YAML output for empty stores list
-        expect(output).toContain('stores');
-    });
-
-    it('should output a single store in YAML format by default', async () => {
-        const { ctx, stdout } = createMockContext({
-            stores: {
-                global: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/mock/store' },
-                },
-            },
-        });
-
-        await handleList(ctx, {}, { stdout });
-
-        const output = captureOutput(stdout);
-        expect(output).toContain('global');
-        expect(output).toContain('/mock/store');
-    });
-
-    it('should output multiple stores sorted alphabetically by name', async () => {
-        const { ctx, stdout } = createMockContext({
-            stores: {
-                zebra: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/path/zebra' },
-                },
-                alpha: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/path/alpha' },
-                },
-                middle: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/path/middle' },
-                },
-            },
-        });
-
-        await handleList(ctx, {}, { stdout });
-
-        const output = captureOutput(stdout);
-        const alphaPos = output.indexOf('alpha');
-        const middlePos = output.indexOf('middle');
-        const zebraPos = output.indexOf('zebra');
-
-        expect(alphaPos).toBeLessThan(middlePos);
-        expect(middlePos).toBeLessThan(zebraPos);
-    });
-
-    it('should output stores in JSON format when format is json', async () => {
-        const { ctx, stdout } = createMockContext({
-            stores: {
-                global: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/mock/store' },
-                },
-            },
-        });
-
-        await handleList(ctx, { format: 'json' }, { stdout });
-
-        const output = captureOutput(stdout);
-        const parsed = JSON.parse(output);
-        const stores = parsed.stores ?? parsed.value?.stores;
-        expect(Array.isArray(stores)).toBe(true);
-        expect(stores).toEqual([
-            {
-                name: 'global',
-                path: '/mock/store',
-            },
-        ]);
-    });
-
-    it('should include store paths in the output', async () => {
-        const { ctx, stdout } = createMockContext({
-            stores: {
-                work: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/home/user/work-memories' },
-                },
-            },
-        });
-
-        await handleList(ctx, {}, { stdout });
-
-        const output = captureOutput(stdout);
-        expect(output).toContain('work');
-        expect(output).toContain('/home/user/work-memories');
-    });
-
-    it('should write output to the injected stdout stream', async () => {
-        const { ctx } = createMockContext();
-        const { PassThrough } = await import('node:stream');
-        const customStdout = new PassThrough();
-        let captured = '';
-        customStdout.on('data', (chunk: Buffer | string) => {
-            captured += chunk.toString();
-        });
-
-        await handleList(ctx, {}, { stdout: customStdout });
-
-        expect(captured.length).toBeGreaterThan(0);
-    });
-
-    it('should use ctx.stdout when no deps.stdout is provided', async () => {
-        const { ctx, stdout } = createMockContext();
-
-        // Call without deps – handler falls back to ctx.stdout then process.stdout.
-        // We cannot easily capture process.stdout, so pass ctx.stdout via deps.
-        await handleList(ctx, {}, { stdout });
-
-        const output = captureOutput(stdout);
-        expect(output.length).toBeGreaterThan(0);
-    });
-
-    it('should output two stores with correct names and paths in YAML', async () => {
-        const { ctx, stdout } = createMockContext({
-            stores: {
-                personal: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/home/user/personal' },
-                },
-                work: {
-                    kind: 'filesystem',
-                    categoryMode: 'free',
-                    categories: {},
-                    properties: { path: '/home/user/work' },
-                },
-            },
-        });
-
-        await handleList(ctx, { format: 'yaml' }, { stdout });
-
-        const output = captureOutput(stdout);
-        expect(output).toContain('personal');
-        expect(output).toContain('/home/user/personal');
-        expect(output).toContain('work');
-        expect(output).toContain('/home/user/work');
-    });
-});