@yeseh/cortex-cli 0.6.8 → 0.6.10

package/src/store/commands/list.ts

@@ -1,102 +0,0 @@
-/**
- * Store list command for displaying all registered stores.
- *
- * This command reads the store registry and displays all registered
- * stores sorted alphabetically by name.
- *
- * @example
- * ```bash
- * # List all stores in YAML format (default)
- * cortex store list
- *
- * # List all stores in JSON format
- * cortex store list --format json
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { type CortexContext } from '@yeseh/cortex-core';
-import { throwCliError } from '../../errors.ts';
-import { createCliCommandContext } from '../../context.ts';
-import { serializeOutput, type OutputStoreRegistry, type OutputFormat } from '../../output.ts';
-
-/**
- * Options for the list command.
- */
-export interface ListCommandOptions {
-    /** Output format (yaml, json, toon) */
-    format?: string;
-}
-
-/**
- * Dependencies for the list command handler.
- * Allows injection for testing.
- */
-export interface ListHandlerDeps {
-    /** Output stream for writing results (defaults to process.stdout) */
-    stdout?: NodeJS.WritableStream;
-}
-
-/**
- * Handles the list command execution.
- *
- * This function:
- * 1. Gets stores from the context
- * 2. Formats the stores as a sorted list
- * 3. Serializes and outputs the result
- *
- * @param ctx - The Cortex context containing stores configuration
- * @param options - Command options (format)
- * @param deps - Optional dependencies for testing
- * @throws {CommanderError} When serialization fails
- */
-export async function handleList(
-    ctx: CortexContext,
-    options: ListCommandOptions,
-    deps: ListHandlerDeps = {},
-): Promise<void> {
-    // 1. Get stores from context
-    const stores = Object.entries(ctx.stores)
-        .map(([
-            name, def,
-        ]) => ({
-            name,
-            path: (def.properties as { path: string }).path,
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-
-    const output: OutputStoreRegistry = { stores };
-
-    // 2. Serialize and output
-    const format: OutputFormat = (options.format as OutputFormat) ?? 'yaml';
-    const serialized = serializeOutput({ kind: 'store-registry', value: output }, format);
-    if (!serialized.ok()) {
-        throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-    }
-
-    const out = deps.stdout ?? process.stdout;
-    out.write(serialized.value + '\n');
-}
-
-/**
- * The `list` subcommand for displaying all registered stores.
- *
- * Reads the store registry and displays all stores sorted alphabetically
- * by name in the specified format.
- *
- * @example
- * ```bash
- * cortex store list
- * cortex store list --format json
- * ```
- */
-export const listCommand = new Command('list')
-    .description('List all registered stores')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)', 'yaml')
-    .action(async (options) => {
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-        await handleList(context.value, options);
-    });

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

@@ -1,120 +0,0 @@
-/**
- * Unit tests for the store prune command handler.
- *
- * @module cli/store/commands/prune.spec
- */
-
-import { describe, it, expect } from 'bun:test';
-import { handlePrune } from './prune.ts';
-import {
-    createMockContext,
-    captureOutput,
-    expectCommanderError,
-    errResult,
-    okResult,
-} from '../../test-helpers.spec.ts';
-
-describe('handlePrune', () => {
-    it('should use default store when no store name is provided', async () => {
-        const { ctx, stdout } = createMockContext();
-        const calls: string[] = [];
-
-        const root = {
-            prune: async () => okResult({ pruned: [] }),
-        };
-
-        (ctx.cortex as unknown as { getStore: (name: string) => unknown }).getStore = (name: string) => {
-            calls.push(name);
-            return okResult({ root: () => okResult(root) });
-        };
-
-        await handlePrune(ctx, undefined, {}, { stdout });
-
-        expect(calls).toEqual(['global']);
-        expect(captureOutput(stdout)).toContain('No expired memories found.');
-    });
-
-    it('should output dry-run preview when --dry-run is enabled', async () => {
-        const { ctx, stdout } = createMockContext();
-
-        const root = {
-            prune: async () =>
-                okResult({
-                    pruned: [{ path: 'project/old-memory' }, { path: 'notes/expired' }],
-                }),
-        };
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => okResult(root) });
-
-        await handlePrune(ctx, 'work', { dryRun: true }, { stdout });
-
-        const output = captureOutput(stdout);
-        expect(output).toContain('Would prune 2 expired memories:');
-        expect(output).toContain('project/old-memory');
-        expect(output).toContain('notes/expired');
-    });
-
-    it('should output prune summary when dry-run is disabled', async () => {
-        const { ctx, stdout } = createMockContext();
-
-        const root = {
-            prune: async () =>
-                okResult({
-                    pruned: [{ path: 'inbox/obsolete' }],
-                }),
-        };
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => okResult(root) });
-
-        await handlePrune(ctx, 'work', { dryRun: false }, { stdout });
-
-        const output = captureOutput(stdout);
-        expect(output).toContain('Pruned 1 expired memories:');
-        expect(output).toContain('inbox/obsolete');
-    });
-
-    it('should throw CommanderError when store resolution fails', async () => {
-        const { ctx } = createMockContext();
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            errResult({ code: 'STORE_NOT_FOUND', message: 'Store not found' });
-
-        await expectCommanderError(
-            () => handlePrune(ctx, 'missing', {}, {}),
-            'STORE_NOT_FOUND',
-            'Store not found',
-        );
-    });
-
-    it('should throw CommanderError when root category cannot be loaded', async () => {
-        const { ctx } = createMockContext();
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => errResult({ code: 'CATEGORY_NOT_FOUND', message: 'Root missing' }) });
-
-        await expectCommanderError(
-            () => handlePrune(ctx, 'global', {}, {}),
-            'CATEGORY_NOT_FOUND',
-            'Root missing',
-        );
-    });
-
-    it('should throw CommanderError when prune operation fails', async () => {
-        const { ctx } = createMockContext();
-
-        const root = {
-            prune: async () => errResult({ code: 'PRUNE_FAILED', message: 'Unable to prune' }),
-        };
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => okResult(root) });
-
-        await expectCommanderError(
-            () => handlePrune(ctx, 'global', {}, {}),
-            'PRUNE_FAILED',
-            'Unable to prune',
-        );
-    });
-});

package/src/store/commands/prune.ts

@@ -1,152 +0,0 @@
-/**
- * Store prune command for removing expired memories.
- *
- * This command removes expired memories from the current store or a specified
- * store. It supports a dry-run mode to preview what would be deleted.
- *
- * @module cli/commands/store/prune
- *
- * @example
- * ```bash
- * # Prune expired memories from the current store
- * cortex store prune
- *
- * # Preview what would be pruned (dry-run)
- * cortex store prune --dry-run
- *
- * # Prune from a specific store
- * cortex --store work store prune
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { type CortexContext } from '@yeseh/cortex-core';
-import { createCliCommandContext } from '../../context.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/**
- * Options for the prune command.
- */
-export interface PruneCommandOptions {
-    /** Show what would be pruned without actually deleting */
-    dryRun?: boolean;
-}
-
-/**
- * Dependencies for the prune command handler.
- * Allows injection for testing.
- */
-export interface PruneHandlerDeps {
-    /** Output stream for writing results (defaults to process.stdout) */
-    stdout?: NodeJS.WritableStream;
-    /** Current time for expiry checks (defaults to ctx.now()) */
-    now?: Date;
-}
-
-/**
- * Handles the prune command execution.
- *
- * Thin CLI handler that delegates all business logic to the core
- * prune operation via CategoryClient. This handler is responsible
- * only for:
- * 1. Resolving the store via CortexContext
- * 2. Calling the category prune operation
- * 3. Formatting output for the CLI (dry-run preview vs. deletion summary)
- *
- * After pruning, the core operation automatically triggers a reindex to
- * clean up category indexes for removed memories.
- *
- * @module cli/commands/store/prune
- *
- * @param ctx - CortexContext providing access to Cortex client
- * @param storeName - Optional store name from the parent `--store` flag;
- *   when `undefined`, resolves the default store
- * @param options - Command options controlling pruning behavior
- * @param options.dryRun - When `true`, lists expired memories without deleting
- * @param deps - Optional injected dependencies for testing
- * @throws {InvalidArgumentError} When the store cannot be resolved
- *   (e.g., store name does not exist)
- * @throws {CommanderError} When the core prune operation fails
- *   (e.g., I/O errors, serialization failures)
- *
- * @example
- * ```typescript
- * // Direct invocation in tests
- * const out = new PassThrough();
- * await handlePrune(ctx, 'my-store', { dryRun: true }, {
- *   stdout: out,
- *   now: new Date('2025-01-01'),
- * });
- * ```
- */
-export async function handlePrune(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    options: PruneCommandOptions,
-    deps: PruneHandlerDeps = {}
-): Promise<void> {
-    const now = deps.now ?? ctx.now();
-    const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
-
-    // Get store through Cortex client
-    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
-    if (!storeResult.ok()) {
-        throwCliError(storeResult.error);
-    }
-
-    const store = storeResult.value;
-    const rootResult = store.root();
-    if (!rootResult.ok()) {
-        throwCliError(rootResult.error);
-    }
-
-    // Use the category's prune method
-    const result = await rootResult.value.prune({
-        dryRun: options.dryRun,
-        now,
-    });
-
-    if (!result.ok()) {
-        throwCliError(result.error);
-    }
-
-    const pruned = result.value.pruned;
-
-    // Format output
-    if (pruned.length === 0) {
-        stdout.write('No expired memories found.\n');
-        return;
-    }
-
-    const paths = pruned.map((entry) => entry.path).join('\n  ');
-    if (options.dryRun) {
-        stdout.write(`Would prune ${pruned.length} expired memories:\n  ${paths}\n`);
-    } else {
-        stdout.write(`Pruned ${pruned.length} expired memories:\n  ${paths}\n`);
-    }
-}
-
-/**
- * The `prune` subcommand for removing expired memories.
- *
- * Removes all expired memories from the store. Use --dry-run to preview
- * what would be deleted without actually removing anything.
- *
- * @example
- * ```bash
- * cortex store prune
- * cortex store prune --dry-run
- * ```
- */
-export const pruneCommand = new Command('prune')
-    .description('Remove expired memories from the store')
-    .option('--dry-run', 'Show what would be pruned without deleting')
-    .action(async (options, command) => {
-        const parentOpts = command.parent?.opts() as { store?: string } | undefined;
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-        await handlePrune(context.value, parentOpts?.store, options);
-    });

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

@@ -1,94 +0,0 @@
-/**
- * Unit tests for the store reindex command handler.
- *
- * @module cli/store/commands/reindexs.spec
- */
-
-import { describe, it, expect } from 'bun:test';
-import { handleReindex } from './reindexs.ts';
-import {
-    createMockContext,
-    captureOutput,
-    expectCommanderError,
-    errResult,
-    okResult,
-} from '../../test-helpers.spec.ts';
-
-describe('handleReindex', () => {
-    it('should use default store when no store name is provided', async () => {
-        const { ctx, stdout } = createMockContext();
-        const calls: string[] = [];
-
-        const root = {
-            reindex: async () => okResult({ warnings: [] }),
-        };
-
-        (ctx.cortex as unknown as { getStore: (name: string) => unknown }).getStore = (name: string) => {
-            calls.push(name);
-            return okResult({ root: () => okResult(root) });
-        };
-
-        await handleReindex(ctx, undefined, { stdout });
-
-        expect(calls).toEqual(['global']);
-        expect(captureOutput(stdout)).toContain("Reindexed category indexes for store 'global'.");
-    });
-
-    it('should output success message for an explicit store', async () => {
-        const { ctx, stdout } = createMockContext();
-
-        const root = {
-            reindex: async () => okResult({ warnings: [] }),
-        };
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => okResult(root) });
-
-        await handleReindex(ctx, 'work', { stdout });
-
-        expect(captureOutput(stdout)).toContain("Reindexed category indexes for store 'work'.");
-    });
-
-    it('should throw CommanderError when store resolution fails', async () => {
-        const { ctx } = createMockContext();
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            errResult({ code: 'STORE_NOT_FOUND', message: 'Store not found' });
-
-        await expectCommanderError(
-            () => handleReindex(ctx, 'missing'),
-            'STORE_NOT_FOUND',
-            'Store not found',
-        );
-    });
-
-    it('should throw CommanderError when root category cannot be loaded', async () => {
-        const { ctx } = createMockContext();
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => errResult({ code: 'CATEGORY_NOT_FOUND', message: 'Root missing' }) });
-
-        await expectCommanderError(
-            () => handleReindex(ctx, 'global'),
-            'CATEGORY_NOT_FOUND',
-            'Root missing',
-        );
-    });
-
-    it('should map reindex failures to REINDEX_FAILED', async () => {
-        const { ctx } = createMockContext();
-
-        const root = {
-            reindex: async () => errResult({ code: 'INDEX_WRITE_FAILED', message: 'Index write failed' }),
-        };
-
-        (ctx.cortex as unknown as { getStore: () => unknown }).getStore = () =>
-            okResult({ root: () => okResult(root) });
-
-        await expectCommanderError(
-            () => handleReindex(ctx, 'global'),
-            'REINDEX_FAILED',
-            'Index write failed',
-        );
-    });
-});

package/src/store/commands/reindexs.ts

@@ -1,97 +0,0 @@
-/**
- * Store reindex command for rebuilding category indexes.
- *
- * This command rebuilds the category indexes for a store, which can help
- * repair corrupted indexes or synchronize them after manual file changes.
- *
- * @example
- * ```bash
- * # Reindex the default store
- * cortex store reindex
- *
- * # Reindex a specific named store
- * cortex store --store work reindex
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { type CortexContext } from '@yeseh/cortex-core';
-import { createCliCommandContext } from '../../context.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/**
- * Dependencies for the reindex command handler.
- * Allows injection for testing.
- */
-export interface ReindexHandlerDeps {
-    /** Output stream for writing results (defaults to process.stdout) */
-    stdout?: NodeJS.WritableStream;
-}
-
-/**
- * Handles the reindex command execution.
- *
- * This function:
- * 1. Resolves the store context (from --store option or default resolution)
- * 2. Gets the root category for the store
- * 3. Rebuilds the category indexes
- * 4. Outputs the result
- *
- * @param ctx - The Cortex context
- * @param storeName - Optional store name from parent --store option
- * @param deps - Optional dependencies for testing
- * @throws {CommanderError} When store resolution or reindexing fails
- */
-export async function handleReindex(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    deps: ReindexHandlerDeps = {}
-): Promise<void> {
-    const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
-
-    // Get store through Cortex client
-    const effectiveStoreName = resolveDefaultStore(ctx, storeName);
-    const storeResult = ctx.cortex.getStore(effectiveStoreName);
-    if (!storeResult.ok()) {
-        throwCliError(storeResult.error);
-    }
-
-    const store = storeResult.value;
-    const rootResult = store.root();
-    if (!rootResult.ok()) {
-        throwCliError(rootResult.error);
-    }
-
-    // Use the category's reindex method
-    const reindexResult = await rootResult.value.reindex();
-    if (!reindexResult.ok()) {
-        throwCliError({ code: 'REINDEX_FAILED', message: reindexResult.error.message });
-    }
-
-    // Output result
-    stdout.write(`Reindexed category indexes for store '${effectiveStoreName}'.\n`);
-}
-
-/**
- * The `reindex` subcommand for rebuilding category indexes.
- *
- * Rebuilds the category indexes for a store, which can help repair corrupted
- * indexes or synchronize them after manual file changes.
- *
- * @example
- * ```bash
- * cortex store reindex
- * cortex store --store work reindex
- * ```
- */
-export const reindexCommand = new Command('reindex')
-    .description('Rebuild category indexes for the store')
-    .action(async (_options, command) => {
-        const parentOpts = command.parent?.opts() as { store?: string } | undefined;
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-        await handleReindex(context.value, parentOpts?.store);
-    });

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

@@ -1,97 +0,0 @@
-/**
- * Unit tests for the store remove command handler.
- *
- * Note: `handleRemove` reads and writes the global config file via `Bun.file()` and
- * `Bun.write()`. These I/O calls are not dependency-injected, so the success
- * path is not testable at the unit level without filesystem mocking (prohibited
- * by project rules). Only the validation paths that throw before any I/O are
- * covered here.
- *
- * Slug normalization behavior: `Slug.from()` normalizes most inputs rather than
- * rejecting them. Only empty/whitespace strings fail `Slug.from()` and produce
- * `InvalidArgumentError`.
- *
- * @module cli/store/commands/remove.spec
- */
-
-import { describe, it } from 'bun:test';
-import { handleRemove } from './remove.ts';
-import {
-    createMockContext,
-    expectInvalidArgumentError,
-    expectCommanderError,
-} from '../../test-helpers.spec.ts';
-
-describe('handleRemove', () => {
-    describe('store name validation', () => {
-        it('should throw InvalidArgumentError for an empty store name', async () => {
-            const { ctx } = createMockContext();
-
-            await expectInvalidArgumentError(
-                () => handleRemove(ctx, ''),
-                'Store name must be a lowercase slug',
-            );
-        });
-
-        it('should throw InvalidArgumentError for a whitespace-only store name', async () => {
-            const { ctx } = createMockContext();
-
-            await expectInvalidArgumentError(
-                () => handleRemove(ctx, '   '),
-                'Store name must be a lowercase slug',
-            );
-        });
-    });
-
-    describe('store not found check', () => {
-        it('should throw CommanderError when the store does not exist in context', async () => {
-            // Provide an empty store registry so any store name fails the check
-            const { ctx } = createMockContext({ stores: {} });
-
-            await expectCommanderError(
-                () => handleRemove(ctx, 'nonexistent'),
-                'STORE_NOT_FOUND',
-                'not registered',
-            );
-        });
-
-        it('should throw CommanderError with the store name included in message', async () => {
-            const { ctx } = createMockContext({ stores: {} });
-
-            await expectCommanderError(
-                () => handleRemove(ctx, 'my-store'),
-                'STORE_NOT_FOUND',
-                'my-store',
-            );
-        });
-
-        it('should throw CommanderError for a valid name not in context', async () => {
-            const { ctx } = createMockContext({
-                stores: {
-                    global: {
-                        kind: 'filesystem',
-                        categoryMode: 'free',
-                        categories: {},
-                        properties: { path: '/default/path' },
-                    },
-                },
-            });
-
-            // 'work' is a valid slug but not registered in this context
-            await expectCommanderError(() => handleRemove(ctx, 'work'), 'STORE_NOT_FOUND');
-        });
-
-        it('should normalize the name before checking for store existence', async () => {
-            // Slug.from('WORK') → 'work'; if 'work' is not in stores, STORE_NOT_FOUND
-            const { ctx } = createMockContext({ stores: {} });
-
-            await expectCommanderError(() => handleRemove(ctx, 'WORK'), 'STORE_NOT_FOUND');
-        });
-    });
-
-    // NOTE: The success path (steps 3–6) requires reading and writing the global
-    // config file via Bun.file() / Bun.write(). These calls use the hardcoded
-    // getDefaultConfigPath() with no injection point, so they cannot be tested
-    // at the unit level without filesystem mocking (which is prohibited).
-    // The success path should be covered by integration tests.
-});