@yeseh/cortex-cli 0.6.8 → 0.6.10

package/src/memory/commands/list.ts

@@ -1,269 +0,0 @@
-/**
- * Memory list command for browsing memories with optional filtering.
- *
- * Lists all memories in a category, or all memories across all categories
- * if no category is specified. Expired memories are excluded by default
- * unless the `--include-expired` flag is provided.
- *
- * When no category is specified, the command dynamically discovers all
- * root categories from the store's index rather than using a hardcoded list.
- *
- * @example
- * ```bash
- * # List all memories
- * cortex memory list
- *
- * # List memories in a specific category
- * cortex memory list project/cortex
- *
- * # Include expired memories
- * cortex memory list --include-expired
- *
- * # Output in JSON format
- * cortex memory list --format json
- *
- * # Use a specific store (either placement works)
- * cortex memory list -s my-store
- * cortex memory -s my-store list
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-
-import { CategoryPath, type CategoryClient } from '@yeseh/cortex-core/category';
-import { serialize, type CortexContext } from '@yeseh/cortex-core';
-import type { SubcategoryEntry } from '@yeseh/cortex-core/category';
-import { type OutputFormat } from '../../output.ts';
-import { createCliCommandContext } from '../../context.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/**
- * Options for the list command.
- */
-export interface ListCommandOptions {
-    /** Include expired memories in the output */
-    includeExpired?: boolean;
-    /** Output format (yaml, json, toon) */
-    format?: string;
-    /** Store name (can be specified on subcommand or parent) */
-    store?: 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;
-    /** Current time for expiration checks */
-    now?: Date;
-}
-
-/**
- * Entry representing a memory in the list output.
- */
-export interface ListMemoryEntry {
-    path: string;
-    tokenEstimate: number;
-    summary?: string;
-    expiresAt?: Date;
-    isExpired: boolean;
-}
-
-/**
- * Entry representing a subcategory in the list output.
- */
-export interface ListSubcategoryEntry {
-    path: string;
-    memoryCount: number;
-    description?: string;
-}
-
-/**
- * Result of the list command containing memories and subcategories.
- */
-export interface ListResult {
-    memories: ListMemoryEntry[];
-    subcategories: ListSubcategoryEntry[];
-}
-
-/**
- * Handles the list command execution.
- *
- * This function:
- * 1. Resolves the store context
- * 2. Loads category index (or all categories if none specified)
- * 3. Collects memories and subcategories, filtering expired if needed
- * 4. Formats and outputs the result
- *
- * @param category - Optional category path to list (lists all if omitted)
- * @param options - Command options (includeExpired, format)
- * @param storeName - Optional store name from parent command
- * @param deps - Optional dependencies for testing
- * @throws {InvalidArgumentError} When arguments are invalid
- * @throws {CommanderError} When read or parse fails
- */
-export async function handleList(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    category: string | undefined,
-    options: ListCommandOptions,
-    deps: ListHandlerDeps = {}
-): Promise<void> {
-    const categoryResult = CategoryPath.fromString(category ?? '');
-    if (!categoryResult.ok()) {
-        throwCliError(categoryResult.error);
-    }
-
-    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
-    if (!storeResult.ok()) {
-        throwCliError(storeResult.error);
-    }
-
-    const rootResult = storeResult.value.root();
-    if (!rootResult.ok()) {
-        throwCliError(rootResult.error);
-    }
-
-    const root = rootResult.value;
-    let categoryClient: CategoryClient;
-
-    if (categoryResult.value.isRoot) {
-        categoryClient = root;
-    } else {
-        const categoryClientResult = root.getCategory(categoryResult.value.toString());
-        if (!categoryClientResult.ok()) {
-            throwCliError(categoryClientResult.error);
-        }
-
-        categoryClient = categoryClientResult.value;
-    }
-    const now = deps.now ?? ctx.now();
-    const includeExpired = options.includeExpired ?? false;
-    const visited = new Set<string>();
-
-    const collectMemories = async (client: CategoryClient): Promise<ListMemoryEntry[]> => {
-        const categoryKey = client.rawPath;
-        if (visited.has(categoryKey)) {
-            return [];
-        }
-        visited.add(categoryKey);
-
-        const memoriesResult = await client.listMemories({ includeExpired });
-        if (!memoriesResult.ok()) {
-            throwCliError(memoriesResult.error);
-        }
-
-        const memories: ListMemoryEntry[] = [];
-        for (const entry of memoriesResult.value) {
-            const memoryClient = client.getMemory(entry.path.slug.toString());
-            const memoryResult = await memoryClient.get({ includeExpired: true, now });
-            if (!memoryResult.ok()) {
-                if (memoryResult.error.code === 'MEMORY_NOT_FOUND') {
-                    continue;
-                }
-                if (!includeExpired && memoryResult.error.code === 'MEMORY_EXPIRED') {
-                    continue;
-                }
-                throwCliError(memoryResult.error);
-            }
-
-            const memory = memoryResult.value;
-            const isExpired = memory.isExpired(now);
-            if (!includeExpired && isExpired) {
-                continue;
-            }
-
-            memories.push({
-                path: entry.path.toString(),
-                tokenEstimate: entry.tokenEstimate,
-                summary: undefined,
-                expiresAt: memory.metadata.expiresAt,
-                isExpired,
-            });
-        }
-
-        const subcategoriesResult = await client.listSubcategories();
-        if (!subcategoriesResult.ok()) {
-            throwCliError(subcategoriesResult.error);
-        }
-
-        for (const subcategory of subcategoriesResult.value) {
-            const subcategoryClientResult = root.getCategory(subcategory.path.toString());
-            if (!subcategoryClientResult.ok()) {
-                throwCliError(subcategoryClientResult.error);
-            }
-            const subMemories = await collectMemories(subcategoryClientResult.value);
-            memories.push(...subMemories);
-        }
-
-        return memories;
-    };
-
-    const subcategoriesResult = await categoryClient.listSubcategories();
-    if (!subcategoriesResult.ok()) {
-        throwCliError(subcategoriesResult.error);
-    }
-
-    const memories = await collectMemories(categoryClient);
-    const result: ListResult = {
-        memories,
-        subcategories: subcategoriesResult.value.map((subcategory: SubcategoryEntry) => ({
-            path: subcategory.path.toString(),
-            memoryCount: subcategory.memoryCount,
-            description: subcategory.description,
-        })),
-    };
-
-    // 3. Format and output
-    const validFormats = ['yaml', 'json', 'toon'] as const;
-    const format: OutputFormat = validFormats.includes(options.format as OutputFormat)
-        ? (options.format as OutputFormat)
-        : 'yaml';
-    const output = serialize(result, format);
-    if (!output.ok()) {
-        throwCliError({ code: 'SERIALIZE_FAILED', message: output.error.message });
-    }
-
-    const out = deps.stdout ?? ctx.stdout;
-    out.write(output.value + '\n');
-}
-
-/**
- * The `list` subcommand for browsing memories.
- *
- * Lists memories in a category, or all memories across all root categories
- * if no category is specified. By default, expired memories are excluded.
- *
- * The `--store` option can be specified either on this command or on the
- * parent `memory` command for flexibility.
- *
- * @example
- * ```bash
- * cortex memory list
- * cortex memory list project/cortex
- * cortex memory list --include-expired
- * cortex memory list --format json
- * cortex memory list -s my-store
- * cortex memory -s my-store list
- * ```
- */
-export const listCommand = new Command('list')
-    .description('List memories in a category')
-    .argument('[category]', 'Category path to list (lists all if omitted)')
-    .option('-s, --store <name>', 'Use a specific named store')
-    .option('-x, --include-expired', 'Include expired memories')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)', 'yaml')
-    .action(async (category, options, command) => {
-        const parentOpts = command.parent?.opts() as { store?: string } | undefined;
-        // Allow store to be specified on either the subcommand or parent command
-        const storeName = options.store ?? parentOpts?.store;
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-
-        await handleList(context.value, storeName, category, options);
-    });

package/src/memory/commands/move.spec.ts

@@ -1,85 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { CommanderError, InvalidArgumentError } from '@commander-js/extra-typings';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { MemoryPath, ok } from '@yeseh/cortex-core';
-
-import { handleMove } from './move.ts';
-import {
-    createCaptureStream,
-    createMemoryCommandContext,
-    createMemoryFixture,
-    createMockMemoryCommandAdapter,
-} from './test-helpers.spec.ts';
-
-describe('handleMove', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-cli-memory-move-'));
-    });
-
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should throw InvalidArgumentError for invalid memory paths', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-        });
-
-        await expect(handleMove(ctx, undefined, 'invalid', 'project/two')).rejects.toThrow(
-            InvalidArgumentError,
-        );
-    });
-
-    it('should throw CommanderError when store is missing', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stores: undefined,
-        });
-
-        await expect(handleMove(ctx, 'missing-store', 'project/one', 'project/two')).rejects.toThrow(
-            CommanderError,
-        );
-    });
-
-    it('should move memory and report output', async () => {
-        const memory = createMemoryFixture('project/from');
-        const moveCalls: { from: MemoryPath; to: MemoryPath }[] = [];
-
-        const adapter = createMockMemoryCommandAdapter({
-            memories: {
-                load: async (path: MemoryPath) => {
-                    if (path.toString() === 'project/from') {
-                        return ok(memory);
-                    }
-                    return ok(null);
-                },
-                move: async (from: MemoryPath, to: MemoryPath) => {
-                    moveCalls.push({ from, to });
-                    return ok(undefined);
-                },
-            },
-        });
-
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter,
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleMove(ctx, undefined, 'project/from', 'project/to');
-
-        expect(moveCalls).toHaveLength(1);
-        if (moveCalls[0]) {
-            expect(moveCalls[0].from.toString()).toBe('project/from');
-            expect(moveCalls[0].to.toString()).toBe('project/to');
-        }
-        expect(capture.getOutput()).toContain('Moved memory project/from to project/to');
-    });
-});

package/src/memory/commands/move.ts

@@ -1,119 +0,0 @@
-/**
- * Memory move command implementation using Commander.js.
- *
- * Moves a memory from one path to another within the same store.
- *
- * @example
- * ```bash
- * # Move a memory to a new location
- * cortex memory move project/old-name project/new-name
- *
- * # Move with explicit store
- * cortex memory --store my-store move project/old project/new
- * ```\n */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { MemoryPath, type CortexContext } from '@yeseh/cortex-core';
-import { createCliCommandContext } from '../../context.ts';
-import { serializeOutput, type OutputFormat } from '../../output.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/** Options for the move command. */
-export interface MoveCommandOptions {
-    /** Output format (yaml, json, toon) */
-    format?: string;
-}
-
-/**
- * Handler for the memory move command.
- * Exported for direct testing without Commander parsing.
- *
- * @param ctx - CLI context containing Cortex client and streams
- * @param storeName - Optional store name from parent command
- * @param from - Source memory path
- * @param to - Destination memory path
- */
-export async function handleMove(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    from: string,
-    to: string,
-    options: MoveCommandOptions = {}
-): Promise<void> {
-    const fromResult = MemoryPath.fromString(from);
-    if (!fromResult.ok()) {
-        throwCliError(fromResult.error);
-    }
-
-    const toResult = MemoryPath.fromString(to);
-    if (!toResult.ok()) {
-        throwCliError(toResult.error);
-    }
-
-    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);
-    }
-
-    const sourceCategoryResult = fromResult.value.category.isRoot
-        ? rootResult
-        : rootResult.value.getCategory(fromResult.value.category.toString());
-    if (!sourceCategoryResult.ok()) {
-        throwCliError(sourceCategoryResult.error);
-    }
-
-    const sourceMemory = sourceCategoryResult.value.getMemory(fromResult.value.slug.toString());
-    const moveResult = await sourceMemory.move(toResult.value);
-    if (!moveResult.ok()) {
-        throwCliError(moveResult.error);
-    }
-
-    const out = ctx.stdout ?? process.stdout;
-    const rawFormat = options.format;
-    if (!rawFormat) {
-        out.write(`Moved memory ${fromResult.value.toString()} to ${toResult.value.toString()}.\n`);
-    } else {
-        const format = rawFormat as OutputFormat;
-        const serialized = serializeOutput(
-            {
-                kind: 'moved-memory',
-                value: { from: fromResult.value.toString(), to: toResult.value.toString() },
-            },
-            format
-        );
-        if (!serialized.ok()) {
-            throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-        }
-        out.write(serialized.value + '\n');
-    }
-}
-
-/**
- * The `memory move` subcommand.
- *
- * Moves a memory from one path to another within the store.
- * Both paths must be valid memory slug paths.
- *
- * The `--store` option is inherited from the parent `memory` command.
- */
-export const moveCommand = new Command('move')
-    .description('Move a memory to a new path')
-    .argument('<from>', 'Source memory path')
-    .argument('<to>', 'Destination memory path')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)')
-    .action(async (from, to, options, command) => {
-        const parentOpts = command.parent?.opts() as { store?: string } | undefined;
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-
-        await handleMove(context.value, parentOpts?.store, from, to, options);
-    });

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

@@ -1,79 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { CommanderError, InvalidArgumentError } from '@commander-js/extra-typings';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { MemoryPath, ok } from '@yeseh/cortex-core';
-
-import { handleRemove } from './remove.ts';
-import {
-    createCaptureStream,
-    createMemoryCommandContext,
-    createMemoryFixture,
-    createMockMemoryCommandAdapter,
-} from './test-helpers.spec.ts';
-
-describe('handleRemove', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-cli-memory-remove-'));
-    });
-
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should throw InvalidArgumentError for invalid memory paths', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-        });
-
-        await expect(handleRemove(ctx, undefined, 'invalid')).rejects.toThrow(
-            InvalidArgumentError,
-        );
-    });
-
-    it('should throw CommanderError when store is missing', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stores: undefined,
-        });
-
-        await expect(handleRemove(ctx, 'missing-store', 'project/one')).rejects.toThrow(
-            CommanderError,
-        );
-    });
-
-    it('should remove memory and report output', async () => {
-        const memory = createMemoryFixture('project/remove');
-        const removeCalls: MemoryPath[] = [];
-
-        const adapter = createMockMemoryCommandAdapter({
-            memories: {
-                load: async () => ok(memory),
-                remove: async (path: MemoryPath) => {
-                    removeCalls.push(path);
-                    return ok(undefined);
-                },
-            },
-        });
-
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter,
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleRemove(ctx, undefined, 'project/remove');
-
-        expect(removeCalls).toHaveLength(1);
-        if (removeCalls[0]) {
-            expect(removeCalls[0].toString()).toBe('project/remove');
-        }
-        expect(capture.getOutput()).toContain('Removed memory project/remove.');
-    });
-});

package/src/memory/commands/remove.ts

@@ -1,108 +0,0 @@
-/**
- * Memory remove command implementation using Commander.js.
- *
- * Deletes an existing memory at the specified path.
- *
- * @example
- * ```bash
- * # Remove a memory
- * cortex memory remove project/tech-stack
- *
- * # Remove memory from a specific store
- * cortex memory --store work remove project/notes
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { MemoryPath, type CortexContext } from '@yeseh/cortex-core';
-import { createCliCommandContext } from '../../context.ts';
-import { serializeOutput, type OutputFormat } from '../../output.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/** Options for the remove command. */
-export interface RemoveCommandOptions {
-    /** Output format (yaml, json, toon) */
-    format?: string;
-}
-
-/**
- * Handler for the memory remove command.
- * Exported for direct testing without Commander parsing.
- *
- * @param ctx - CLI context containing Cortex client and streams
- * @param storeName - Optional store name from parent command
- * @param path - Memory path to remove (e.g., "project/tech-stack")
- */
-export async function handleRemove(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    path: string,
-    options: RemoveCommandOptions = {}
-): Promise<void> {
-    const pathResult = MemoryPath.fromString(path);
-    if (!pathResult.ok()) {
-        throwCliError(pathResult.error);
-    }
-
-    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);
-    }
-
-    const categoryResult = pathResult.value.category.isRoot
-        ? rootResult
-        : rootResult.value.getCategory(pathResult.value.category.toString());
-    if (!categoryResult.ok()) {
-        throwCliError(categoryResult.error);
-    }
-
-    const memoryClient = categoryResult.value.getMemory(pathResult.value.slug.toString());
-    const removeResult = await memoryClient.delete();
-    if (!removeResult.ok()) {
-        throwCliError(removeResult.error);
-    }
-
-    const out = ctx.stdout ?? process.stdout;
-    const rawFormat = options.format;
-    if (!rawFormat) {
-        out.write(`Removed memory ${pathResult.value.toString()}.\n`);
-    } else {
-        const format = rawFormat as OutputFormat;
-        const serialized = serializeOutput(
-            { kind: 'path', value: { path: pathResult.value.toString() } },
-            format
-        );
-        if (!serialized.ok()) {
-            throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-        }
-        out.write(serialized.value + '\n');
-    }
-}
-
-/**
- * The `memory remove` subcommand.
- *
- * Deletes an existing memory at the specified path.
- *
- * The `--store` option is inherited from the parent `memory` command.
- */
-export const removeCommand = new Command('remove')
-    .description('Delete a memory')
-    .argument('<path>', 'Memory path to remove')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)')
-    .action(async (path, options, command) => {
-        const parentOpts = command.parent?.opts() as { store?: string } | undefined;
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-
-        await handleRemove(context.value, parentOpts?.store, path, options);
-    });