@yeseh/cortex-cli 0.6.8 → 0.6.9

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

@@ -1,71 +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 { ok } from '@yeseh/cortex-core';
-
-import { handleShow } from './show.ts';
-import {
-    createCaptureStream,
-    createMemoryCommandContext,
-    createMemoryFixture,
-    createMockMemoryCommandAdapter,
-} from './test-helpers.spec.ts';
-
-describe('handleShow', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-cli-memory-show-'));
-    });
-
-    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(handleShow(ctx, undefined, 'invalid', { format: 'yaml' })).rejects.toThrow(
-            InvalidArgumentError,
-        );
-    });
-
-    it('should throw CommanderError when store is missing', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stores: undefined,
-        });
-
-        await expect(handleShow(ctx, 'missing-store', 'project/one', { format: 'yaml' })).rejects.toThrow(
-            CommanderError,
-        );
-    });
-
-    it('should output serialized memory details', async () => {
-        const memory = createMemoryFixture('project/show', {}, 'Show content');
-        const adapter = createMockMemoryCommandAdapter({
-            memories: {
-                load: async () => ok(memory),
-            },
-        });
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter,
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleShow(ctx, undefined, 'project/show', { format: 'json' });
-
-        const output = JSON.parse(capture.getOutput());
-        expect(output.value.path).toBe('project/show');
-        expect(output.value.content).toBe('Show content');
-        expect(output.value.metadata.tags).toEqual(['test']);
-    });
-});

package/src/memory/commands/show.ts

@@ -1,165 +0,0 @@
-/**
- * Memory show command for displaying a memory's content and metadata.
- *
- * This command reads a memory from the store and displays it in the
- * specified format. Expired memories are excluded by default unless
- * the `--include-expired` flag is provided.
- *
- * @example
- * ```bash
- * # Show a memory in YAML format (default)
- * cortex memory show project/notes
- *
- * # Show a memory in JSON format
- * cortex memory show project/notes --format json
- *
- * # Include expired memories
- * cortex memory show project/notes --include-expired
- *
- * # Use a specific store
- * cortex memory --store my-store show project/notes
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-
-import { defaultTokenizer, MemoryPath, type CortexContext } from '@yeseh/cortex-core';
-import { type StoreClient } from '@yeseh/cortex-core/store';
-import { serializeOutput, type OutputMemory, type OutputFormat } from '../../output.ts';
-import { createCliCommandContext } from '../../context.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/**
- * Options for the show command.
- */
-export interface ShowCommandOptions {
-    /** Include expired memories in the output */
-    includeExpired?: boolean;
-    /** Output format (yaml, json, toon) */
-    format?: string;
-}
-
-/**
- * Dependencies for the show command handler.
- * Allows injection for testing.
- */
-export interface ShowHandlerDeps {
-    /** Output stream for writing results (defaults to process.stdout) */
-    stdout?: NodeJS.WritableStream;
-    /** Pre-resolved store client for testing */
-    store?: StoreClient;
-}
-
-/**
- * Handles the show command execution.
- *
- * This function:
- * 1. Resolves the store context
- * 2. Validates the memory path
- * 3. Reads the memory file from storage
- * 4. Parses the memory content and frontmatter
- * 5. Checks expiration status (unless --include-expired)
- * 6. Serializes and outputs the result
- *
- * @param path - The memory path to show (e.g., "project/notes")
- * @param options - Command options (includeExpired, format)
- * @param storeName - Optional store name from parent command
- * @param deps - Optional dependencies for testing
- * @throws {InvalidArgumentError} When the path is invalid
- * @throws {CommanderError} When the memory is not found or read fails
- */
-export async function handleShow(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    path: string,
-    options: ShowCommandOptions,
-    deps: ShowHandlerDeps = {}
-): 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 = deps.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 readResult = await memoryClient.get({
-        includeExpired: options.includeExpired ?? false,
-        now: ctx.now(),
-    });
-    if (!readResult.ok()) {
-        throwCliError(readResult.error);
-    }
-
-    const memory = readResult.value;
-    const tokenEstimateResult = defaultTokenizer.estimateTokens(memory.content);
-    const tokenEstimate = tokenEstimateResult.ok() ? tokenEstimateResult.value : undefined;
-
-    const outputMemory: OutputMemory = {
-        path: memory.path.toString(),
-        metadata: {
-            createdAt: memory.metadata.createdAt,
-            updatedAt: memory.metadata.updatedAt,
-            tags: memory.metadata.tags,
-            source: memory.metadata.source,
-            tokenEstimate,
-            expiresAt: memory.metadata.expiresAt,
-        },
-        content: memory.content,
-    };
-
-    const format = (options.format as OutputFormat) ?? 'yaml';
-    const serialized = serializeOutput({ kind: 'memory', value: outputMemory }, format);
-    if (!serialized.ok()) {
-        throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-    }
-
-    const out = deps.stdout ?? ctx.stdout;
-    out.write(serialized.value + '\n');
-}
-
-/**
- * The `show` subcommand for displaying a memory.
- *
- * Reads a memory from the store and displays its content and metadata
- * in the specified format. By default, expired memories are excluded.
- *
- * @example
- * ```bash
- * cortex memory show project/notes
- * cortex memory show project/notes --format json
- * cortex memory show project/notes --include-expired
- * ```
- */
-export const showCommand = new Command('show')
-    .description('Display a memory')
-    .argument('<path>', 'Memory path to show')
-    .option('-x, --include-expired', 'Include expired memories')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)', 'yaml')
-    .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 handleShow(context.value, parentOpts?.store, path, options);
-    });

package/src/memory/commands/test-helpers.spec.ts

@@ -1,127 +0,0 @@
-import { PassThrough } from 'node:stream';
-import {
-    Cortex,
-    Memory,
-    ok,
-    type AdapterFactory,
-    type ConfigAdapter,
-    type ConfigStores,
-    type CortexContext,
-    type CortexSettings,
-    type MemoryMetadata,
-    type StorageAdapter,
-} from '@yeseh/cortex-core';
-
-export const createMockMemoryCommandAdapter = (
-    overrides: Record<string, unknown> = {},
-): StorageAdapter =>
-    ({
-        memories: {
-            load: async () => ok(null),
-            save: async () => ok(undefined),
-            add: async () => ok(undefined),
-            remove: async () => ok(undefined),
-            move: async () => ok(undefined),
-            ...(overrides.memories as object | undefined),
-        },
-        indexes: {
-            load: async () => ok(null),
-            write: async () => ok(undefined),
-            reindex: async () => ok({ warnings: [] }),
-            updateAfterMemoryWrite: async () => ok(undefined),
-            ...(overrides.indexes as object | undefined),
-        },
-        categories: {
-            exists: async () => ok(true),
-            ensure: async () => ok(undefined),
-            delete: async () => ok(undefined),
-            setDescription: async () => ok(undefined),
-            ...(overrides.categories as object | undefined),
-        },
-    }) as unknown as StorageAdapter;
-
-export const createMemoryCommandContext = (options: {
-    adapter: StorageAdapter;
-    storePath: string;
-    stdout?: PassThrough;
-    stdin?: PassThrough;
-    stores?: ConfigStores;
-    settings?: CortexSettings;
-    now?: () => Date;
-    adapterFactory?: AdapterFactory;
-}): CortexContext => {
-    const stores: ConfigStores = options.stores ?? {
-        global: {
-            kind: 'filesystem',
-            properties: { path: options.storePath },
-            categories: {},
-        },
-    };
-
-    const cortex = Cortex.init({
-        settings: options.settings,
-        stores,
-        adapterFactory: options.adapterFactory ?? (() => options.adapter),
-    });
-
-    return {
-        cortex,
-        config: {
-            path: '/tmp/test/config.yaml',
-            data: null,
-            get stores() {
-                return stores;
-            },
-            get settings() {
-                return options.settings ?? null;
-            },
-            initializeConfig: async () => ok(undefined),
-            getSettings: async () => ok(options.settings ?? {}),
-            getStores: async () => ok(stores),
-            getStore: async (name: string) => ok(stores[name] ?? null),
-            saveStore: async () => ok(undefined),
-        } as ConfigAdapter,
-        settings: (options.settings ?? {}) as CortexSettings,
-        stores,
-        now: options.now ?? (() => new Date('2025-01-01T00:00:00.000Z')),
-        stdin: (options.stdin ?? new PassThrough()) as unknown as NodeJS.ReadStream,
-        stdout: (options.stdout ?? new PassThrough()) as unknown as NodeJS.WriteStream,
-    };
-};
-
-export const createCaptureStream = (): { stream: PassThrough; getOutput: () => string } => {
-    let output = '';
-    const stream = new PassThrough();
-    const originalWrite = stream.write.bind(stream);
-    stream.write = ((chunk: unknown, encoding?: unknown, cb?: unknown) => {
-        output += Buffer.from(chunk as Buffer).toString(
-            typeof encoding === 'string' ? (encoding as BufferEncoding) : undefined,
-        );
-        return originalWrite(chunk as Buffer, encoding as BufferEncoding, cb as () => void);
-    }) as typeof stream.write;
-
-    return { stream, getOutput: () => output };
-};
-
-export const createMemoryFixture = (
-    path: string,
-    overrides: Partial<MemoryMetadata> = {},
-    content = 'Memory content',
-): Memory => {
-    const timestamp = new Date('2025-01-01T00:00:00.000Z');
-    const metadata: MemoryMetadata = {
-        createdAt: timestamp,
-        updatedAt: timestamp,
-        tags: ['test'],
-        source: 'user',
-        citations: [],
-        ...overrides,
-    };
-
-    const result = Memory.init(path, metadata, content);
-    if (!result.ok()) {
-        throw new Error('Test setup failed to create memory.');
-    }
-
-    return result.value;
-};

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

@@ -1,86 +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 { Memory, MemoryPath, ok } from '@yeseh/cortex-core';
-
-import { handleUpdate } from './update.ts';
-import {
-    createCaptureStream,
-    createMemoryCommandContext,
-    createMemoryFixture,
-    createMockMemoryCommandAdapter,
-} from './test-helpers.spec.ts';
-
-describe('handleUpdate', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-cli-memory-update-'));
-    });
-
-    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(handleUpdate(ctx, undefined, 'invalid', { content: 'Next' })).rejects.toThrow(
-            InvalidArgumentError,
-        );
-    });
-
-    it('should throw CommanderError when store is missing', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stores: undefined,
-        });
-
-        await expect(
-            handleUpdate(ctx, 'missing-store', 'project/one', { content: 'Next' }),
-        ).rejects.toThrow(CommanderError);
-    });
-
-    it('should update memory and report output', async () => {
-        const memory = createMemoryFixture('project/update', {}, 'Original content');
-        const writeCalls: Memory[] = [];
-
-        const adapter = createMockMemoryCommandAdapter({
-            memories: {
-                load: async () => ok(memory),
-                save: async (_: MemoryPath, next: Memory) => {
-                    writeCalls.push(next);
-                    return ok(undefined);
-                },
-            },
-            indexes: {
-                updateAfterMemoryWrite: async () => ok(undefined),
-            },
-        });
-
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter,
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleUpdate(ctx, undefined, 'project/update', {
-            content: 'Updated content',
-            tags: ['new-tag'],
-        });
-
-        expect(writeCalls).toHaveLength(1);
-        if (writeCalls[0]) {
-            expect(writeCalls[0].content).toBe('Updated content');
-            expect(writeCalls[0].metadata.tags).toEqual(['new-tag']);
-        }
-        expect(capture.getOutput()).toContain('Updated memory project/update.');
-    });
-});

package/src/memory/commands/update.ts

@@ -1,230 +0,0 @@
-/**
- * Memory update command implementation using Commander.js.
- *
- * Updates an existing memory at the specified path with new content, tags,
- * or expiration date.
- *
- * @example
- * ```bash
- * # Update memory content inline
- * cortex memory update project/tech-stack --content "Updated stack: TypeScript"
- *
- * # Update memory content from a file
- * cortex memory update project/notes --file ./updated-notes.md
- *
- * # Update tags
- * cortex memory update project/tech-stack --tags "typescript,nodejs,updated"
- *
- * # Update expiration date
- * cortex memory update project/temp --expires-at "2026-12-31T00:00:00Z"
- *
- * # Clear expiration date
- * cortex memory update project/temp --no-expires-at
- *
- * # Update from a specific store
- * cortex memory --store work update project/notes --content "New content"
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { MemoryPath, type CortexContext, type UpdateMemoryInput } from '@yeseh/cortex-core';
-import { resolveInput as resolveCliContent } from '../../utils/input.ts';
-import { parseExpiresAt, parseTags } from '../parsing.ts';
-import { createCliCommandContext } from '../../context.ts';
-import { serializeOutput, type OutputFormat } from '../../output.ts';
-import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
-
-/** Options parsed by Commander for the update command */
-export interface UpdateCommandOptions {
-    content?: string;
-    file?: string;
-    tags?: string[];
-    /**
-     * Expiration date from Commander.js option parsing.
-     * - `string` — ISO 8601 date provided via `--expires-at <date>`
-     * - `false` — expiration cleared via `--no-expires-at` negation flag
-     * - `undefined` (omitted) — keep the existing value unchanged
-     */
-    expiresAt?: string | false;
-    citation?: string[];
-    format?: string;
-}
-
-const parseUpdateExpiresAt = (raw?: string | false): Date | null | undefined => {
-    if (raw === false) {
-        return null;
-    }
-
-    if (!raw) {
-        return undefined;
-    }
-
-    return parseExpiresAt(raw);
-};
-
-const resolveUpdateContent = async (
-    ctx: CortexContext,
-    options: UpdateCommandOptions
-): Promise<string | null> => {
-    if (options.content === undefined && options.file === undefined) {
-        return null;
-    }
-
-    const content = await resolveCliContent({
-        content: options.content,
-        filePath: options.file,
-        stream: ctx.stdin,
-        // `memory update` does not read stdin.
-        stdinRequested: false,
-    });
-
-    if (!content.ok()) {
-        throwCliError(content.error);
-    }
-
-    if (!content.value.content) {
-        throwCliError({
-            code: 'MISSING_CONTENT',
-            message: 'Memory content is required via --content or --file.',
-        });
-    }
-
-    return content.value.content;
-};
-
-const buildUpdates = (
-    content: string | null,
-    tags: string[] | undefined,
-    expiresAt: Date | null | undefined,
-    citations: string[] | undefined
-): UpdateMemoryInput => {
-    const updates: UpdateMemoryInput = {};
-    if (content !== null) {
-        updates.content = content;
-    }
-    if (tags !== undefined) {
-        updates.tags = tags;
-    }
-    if (expiresAt !== undefined) {
-        updates.expiresAt = expiresAt;
-    }
-    if (citations !== undefined) {
-        updates.citations = citations;
-    }
-
-    if (Object.keys(updates).length === 0) {
-        throwCliError({
-            code: 'INVALID_ARGUMENTS',
-            message:
-                'No updates provided. Use --content, --file, --tags, --citation, or expiry flags.',
-        });
-    }
-
-    return updates;
-};
-
-/**
- * Handler for the memory update 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 update (e.g., "project/tech-stack")
- * @param options - Command options from Commander
- */
-export async function handleUpdate(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    path: string,
-    options: UpdateCommandOptions
-): Promise<void> {
-    const pathResult = MemoryPath.fromString(path);
-    if (!pathResult.ok()) {
-        throwCliError(pathResult.error);
-    }
-
-    const content = await resolveUpdateContent(ctx, options);
-    const tags = options.tags === undefined ? undefined : parseTags(options.tags);
-    const expiresAt = parseUpdateExpiresAt(options.expiresAt);
-    const updates = buildUpdates(content, tags, expiresAt, options.citation);
-
-    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 updateResult = await memoryClient.update(updates);
-    if (!updateResult.ok()) {
-        throwCliError(updateResult.error);
-    }
-
-    const memory = updateResult.value;
-    const stdout = ctx.stdout ?? process.stdout;
-
-    const rawFormat = options.format;
-    if (!rawFormat) {
-        stdout.write(`Updated memory ${memory.path.toString()}.\n`);
-    } else {
-        const format = rawFormat as OutputFormat;
-        const serialized = serializeOutput(
-            {
-                kind: 'memory',
-                value: {
-                    path: memory.path.toString(),
-                    metadata: memory.metadata,
-                    content: memory.content,
-                },
-            },
-            format
-        );
-        if (!serialized.ok()) {
-            throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-        }
-        stdout.write(serialized.value + '\n');
-    }
-}
-
-/**
- * The `memory update` subcommand.
- *
- * Updates an existing memory at the specified path. Can update:
- * - Content via `--content` flag for inline text or `--file` to read from a file
- * - Tags via `--tags` flag (replaces existing tags)
- * - Expiration via `--expires-at` or `--no-expires-at`
- *
- * The `--store` option is inherited from the parent `memory` command.
- */
-export const updateCommand = new Command('update')
-    .description('Update an existing memory')
-    .argument('<path>', 'Memory path to update')
-    .option('-c, --content <text>', 'New memory content as inline text')
-    .option('-f, --file <filepath>', 'Read new content from a file')
-    .option('-t, --tags <value...>', 'Tags (can be repeated or comma-separated, replaces existing)')
-    .option('-e, --expires-at <date>', 'New expiration date (ISO 8601)')
-    .option('--no-expires-at', 'Remove expiration date')
-    .option('--citation <value...>', 'Citation references (replaces existing)')
-    .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 handleUpdate(context.value, parentOpts?.store, path, options);
-    });