@yeseh/cortex-cli 0.6.7 → 0.6.9

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

@@ -1,169 +0,0 @@
-/**
- * Unit tests for the handleAdd command handler.
- *
- * @module cli/memory/commands/add.spec
- */
-
-import { describe, it, expect, afterEach, beforeEach } 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 { PassThrough } from 'node:stream';
-import {
-    ok,
-    type AdapterFactory,
-} from '@yeseh/cortex-core';
-import { handleAdd } from './add.ts';
-import {
-    createCaptureStream,
-    createMemoryCommandContext,
-    createMockMemoryCommandAdapter,
-} from './test-helpers.spec.ts';
-
-// ---------------------------------------------------------------------------
-// Local helpers
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('handleAdd', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-add-'));
-    });
-
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should create a memory and write success message to stdout', async () => {
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleAdd(ctx, undefined, 'project/notes', { content: 'Hello world' });
-
-        const out = capture.getOutput();
-        expect(out).toContain('Added memory');
-        expect(out).toContain('project/notes');
-    });
-
-    it('should pass tags from options', async () => {
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleAdd(ctx, undefined, 'project/tagged', {
-            content: 'Tagged memory',
-            tags: ['foo', 'bar'],
-        });
-
-        expect(capture.getOutput()).toContain('Added memory');
-        expect(capture.getOutput()).toContain('project/tagged');
-    });
-
-    it('should pass expiresAt from options', async () => {
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleAdd(ctx, undefined, 'project/expiring', {
-            content: 'Expires soon',
-            expiresAt: '2030-12-31T00:00:00Z',
-        });
-
-        expect(capture.getOutput()).toContain('Added memory');
-    });
-
-    it('should pass citations from options', async () => {
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleAdd(ctx, undefined, 'project/cited', {
-            content: 'Cited memory',
-            citations: ['https://example.com/source'],
-        });
-
-        expect(capture.getOutput()).toContain('Added memory');
-    });
-
-    it('should throw CommanderError when store not found', async () => {
-        const failingFactory = (() => undefined) as unknown as AdapterFactory;
-
-        const stdin = new PassThrough();
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdin,
-            adapterFactory: failingFactory,
-        });
-
-        await expect(
-            handleAdd(ctx, 'nonexistent', 'project/notes', { content: 'test' })
-        ).rejects.toThrow(CommanderError);
-    });
-
-    it('should throw InvalidArgumentError for MISSING_CONTENT when no content provided', async () => {
-        const stdin = new PassThrough();
-        stdin.end(); // EOF with no data → empty content → MISSING_CONTENT
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdin,
-        });
-
-        await expect(handleAdd(ctx, undefined, 'project/notes', {})).rejects.toThrow(
-            InvalidArgumentError
-        );
-    });
-
-    it('should throw CommanderError when memory create fails due to missing category', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter({
-                categories: {
-                    exists: async () => ok(false), // category absent → CATEGORY_NOT_FOUND
-                },
-            }),
-            storePath: tempDir,
-        });
-
-        await expect(
-            handleAdd(ctx, undefined, 'project/notes', { content: 'test' })
-        ).rejects.toThrow(CommanderError);
-    });
-
-    it('should use stdin when no content option is provided', async () => {
-        const stdin = new PassThrough();
-        stdin.end('Content from stdin');
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            stdin,
-            stdout: capture.stream,
-        });
-
-        await handleAdd(ctx, undefined, 'project/stdin', {});
-
-        const out = capture.getOutput();
-        expect(out).toContain('Added memory');
-        expect(out).toContain('stdin');
-    });
-});

package/src/memory/commands/add.ts

@@ -1,158 +0,0 @@
-/**
- * Memory add command implementation using Commander.js.
- *
- * Creates a new memory at the specified path with content from inline text,
- * a file, or stdin.
- *
- * @example
- * ```bash
- * # Add memory with inline content
- * cortex memory add project/tech-stack --content "Using TypeScript and Node.js"
- *
- * # Add memory from a file
- * cortex memory add project/notes --file ./notes.md
- *
- * # Add memory from stdin
- * echo "My notes" | cortex memory add project/notes
- *
- * # Add memory with tags and expiration
- * cortex memory add project/temp --content "Temporary note" \
- *   --tags "temp,cleanup" --expires-at "2025-12-31T00:00:00Z"
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { type CortexContext } 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 add command */
-export interface AddCommandOptions {
-    content?: string;
-    file?: string;
-    tags?: string[];
-    expiresAt?: string;
-    citations?: string[];
-    format?: string;
-}
-/**
- * Handler for the memory add command.
- * Exported for direct testing without Commander parsing.
- *
- * @param path - Memory path (e.g., "project/tech-stack")
- * @param options - Command options from Commander
- * @param storeName - Optional store name from parent command
- * @param deps - Injectable dependencies for testing
- */
-export async function handleAdd(
-    ctx: CortexContext,
-    storeName: string | undefined,
-    path: string,
-    options: AddCommandOptions
-): Promise<void> {
-    const content = await resolveCliContent({
-        content: options.content,
-        filePath: options.file,
-        stream: ctx.stdin,
-        // `memory add` accepts stdin by default (when piped).
-        stdinRequested: options.content === undefined && options.file === undefined,
-    });
-
-    if (!content.ok()) {
-        throwCliError(content.error);
-    }
-
-    if (!content.value.content) {
-        throwCliError({
-            code: 'MISSING_CONTENT',
-            message: 'Memory content is required via --content, --file, or stdin.',
-        });
-    }
-
-    const { content: memoryContent, source } = content.value;
-    const tags = parseTags(options.tags);
-    const expiresAt = parseExpiresAt(options.expiresAt);
-    const citations = options.citations ?? [];
-
-    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
-    if (!storeResult.ok()) {
-        throwCliError(storeResult.error);
-    }
-
-    const store = storeResult.value;
-    const timestamp = ctx.now() ?? new Date();
-    const memoryClient = store.getMemory(path);
-    const memoryResult = await memoryClient.create({
-        content: memoryContent!,
-        metadata: {
-            tags,
-            source,
-            createdAt: timestamp,
-            updatedAt: timestamp,
-            expiresAt,
-            citations,
-        },
-    });
-
-    if (!memoryResult.ok()) {
-        throwCliError(memoryResult.error);
-    }
-
-    const memory = memoryResult.value;
-    const out = ctx.stdout ?? process.stdout;
-
-    const rawFormat = options.format;
-    if (!rawFormat) {
-        out.write(`Added memory ${memory.path} (${source}).\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 });
-        }
-        out.write(serialized.value + '\n');
-    }
-}
-
-/**
- * The `memory add` subcommand.
- *
- * Creates a new memory at the specified path. Content can be provided via:
- * - `--content` flag for inline text
- * - `--file` flag to read from a file
- * - stdin when piped
- *
- * The `--store` option is inherited from the parent `memory` command.
- */
-export const addCommand = new Command('add')
-    .description('Create a new memory')
-    .argument('<path>', 'Memory path (e.g., project/tech-stack)')
-    .option('-c, --content <text>', 'Memory content as inline text')
-    .option('-f, --file <filepath>', 'Read content from a file')
-    .option('-t, --tags <value...>', 'Tags (can be repeated or comma-separated)')
-    .option('-e, --expires-at <date>', 'Expiration date (ISO 8601)')
-    .option('--citation <value...>', 'Citation references (file paths or URLs)')
-    .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 handleAdd(context.value, parentOpts?.store, path, options);
-    });

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

@@ -1,80 +0,0 @@
-/**
- * Unit tests for memory command definitions.
- *
- * Verifies that memory subcommands expose the expected names,
- * arguments, and options.
- *
- * @module cli/memory/commands/definitions.spec
- */
-
-import { describe, expect, it } from 'bun:test';
-
-import { listCommand } from './list.ts';
-import { moveCommand } from './move.ts';
-import { removeCommand } from './remove.ts';
-import { showCommand } from './show.ts';
-import { updateCommand } from './update.ts';
-
-const getLongOptions = (command: { options: ReadonlyArray<{ long?: string }> }): string[] =>
-    command.options.map((option) => option.long ?? '').filter(Boolean);
-
-describe('memory command definitions', () => {
-    describe('listCommand', () => {
-        it('should expose expected command name and usage', () => {
-            expect(listCommand.name()).toBe('list');
-            expect(listCommand.usage()).toContain('[category]');
-        });
-
-        it('should register expected options', () => {
-            const options = getLongOptions(listCommand);
-            expect(options).toContain('--store');
-            expect(options).toContain('--include-expired');
-            expect(options).toContain('--format');
-        });
-    });
-
-    describe('moveCommand', () => {
-        it('should expose expected command name and usage', () => {
-            expect(moveCommand.name()).toBe('move');
-            expect(moveCommand.usage()).toContain('<from>');
-            expect(moveCommand.usage()).toContain('<to>');
-        });
-    });
-
-    describe('removeCommand', () => {
-        it('should expose expected command name and usage', () => {
-            expect(removeCommand.name()).toBe('remove');
-            expect(removeCommand.usage()).toContain('<path>');
-        });
-    });
-
-    describe('showCommand', () => {
-        it('should expose expected command name and usage', () => {
-            expect(showCommand.name()).toBe('show');
-            expect(showCommand.usage()).toContain('<path>');
-        });
-
-        it('should register expected options', () => {
-            const options = getLongOptions(showCommand);
-            expect(options).toContain('--include-expired');
-            expect(options).toContain('--format');
-        });
-    });
-
-    describe('updateCommand', () => {
-        it('should expose expected command name and usage', () => {
-            expect(updateCommand.name()).toBe('update');
-            expect(updateCommand.usage()).toContain('<path>');
-        });
-
-        it('should register expected options', () => {
-            const options = getLongOptions(updateCommand);
-            expect(options).toContain('--content');
-            expect(options).toContain('--file');
-            expect(options).toContain('--tags');
-            expect(options).toContain('--expires-at');
-            expect(options).toContain('--no-expires-at');
-            expect(options).toContain('--citation');
-        });
-    });
-});

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

@@ -1,123 +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 {
-    CategoryPath,
-    MemoryPath,
-    ok,
-    type AdapterFactory,
-    type Category,
-} from '@yeseh/cortex-core';
-
-import { handleList } from './list.ts';
-import {
-    createCaptureStream,
-    createMemoryCommandContext,
-    createMemoryFixture,
-    createMockMemoryCommandAdapter,
-} from './test-helpers.spec.ts';
-
-describe('handleList', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cortex-cli-memory-list-'));
-    });
-
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should throw InvalidArgumentError for invalid category paths', async () => {
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-        });
-
-        await expect(handleList(ctx, undefined, '/ /', { format: 'yaml' })).rejects.toThrow(
-            InvalidArgumentError,
-        );
-    });
-
-    it('should throw CommanderError when the adapter factory returns nothing', async () => {
-        const nullFactory = (() => undefined) as unknown as AdapterFactory;
-        const ctx = createMemoryCommandContext({
-            adapter: createMockMemoryCommandAdapter(),
-            storePath: tempDir,
-            adapterFactory: nullFactory,
-            stores: {
-                global: {
-                    kind: 'filesystem',
-                    properties: { path: tempDir },
-                    categories: {},
-                },
-            },
-        });
-
-        await expect(handleList(ctx, 'missing-store', undefined, {})).rejects.toThrow(
-            CommanderError,
-        );
-    });
-
-    it('should write serialized list output', async () => {
-        const memoryPath = MemoryPath.fromString('project/one');
-        if (!memoryPath.ok()) {
-            throw new Error('Test setup failed to create memory path.');
-        }
-        const memory = createMemoryFixture('project/one');
-
-        const rootCategory: Category = {
-            memories: [],
-            subcategories: [
-                {
-                    path: CategoryPath.fromString('project').unwrap(),
-                    memoryCount: 1,
-                    description: 'Project memories',
-                },
-            ],
-        };
-
-        const projectCategory: Category = {
-            memories: [
-                {
-                    path: memoryPath.value,
-                    tokenEstimate: 42,
-                },
-            ],
-            subcategories: [],
-        };
-
-        const adapter = createMockMemoryCommandAdapter({
-            indexes: {
-                load: async (path: CategoryPath) => {
-                    if (path.isRoot) {
-                        return ok(rootCategory);
-                    }
-                    if (path.toString() === 'project') {
-                        return ok(projectCategory);
-                    }
-                    return ok(null);
-                },
-            },
-            memories: {
-                load: async () => ok(memory),
-            },
-        });
-
-        const capture = createCaptureStream();
-        const ctx = createMemoryCommandContext({
-            adapter,
-            storePath: tempDir,
-            stdout: capture.stream,
-        });
-
-        await handleList(ctx, undefined, undefined, { format: 'json' });
-
-        const output = JSON.parse(capture.getOutput());
-        expect(output.memories).toHaveLength(1);
-        expect(output.memories[0].path).toBe('project/one');
-        expect(output.subcategories[0].path).toBe('project');
-    });
-});