@yeseh/cortex-cli 0.6.8 → 0.6.9

package/src/memory/index.spec.ts

@@ -1,59 +0,0 @@
-/**
- * Unit tests for memory command group wiring.
- *
- * Verifies that the `memory` command group is correctly configured with
- * the expected name, description, options, and subcommands.
- *
- * @module cli/memory/index.spec
- */
-
-import { describe, it, expect } from 'bun:test';
-
-import { memoryCommand } from './index.ts';
-
-describe('memoryCommand', () => {
-    it('should have name "memory"', () => {
-        expect(memoryCommand.name()).toBe('memory');
-    });
-
-    it('should have description', () => {
-        expect(memoryCommand.description()).toBeTruthy();
-    });
-
-    it('should have --store option', () => {
-        const options = memoryCommand.options;
-        const storeOption = options.find((o) => o.long === '--store');
-        expect(storeOption).toBeDefined();
-        expect(storeOption?.short).toBe('-s');
-    });
-
-    it('should have "add" subcommand registered', () => {
-        const names = memoryCommand.commands.map((c) => c.name());
-        expect(names).toContain('add');
-    });
-
-    it('should have "show" subcommand registered', () => {
-        const names = memoryCommand.commands.map((c) => c.name());
-        expect(names).toContain('show');
-    });
-
-    it('should have "update" subcommand registered', () => {
-        const names = memoryCommand.commands.map((c) => c.name());
-        expect(names).toContain('update');
-    });
-
-    it('should have "remove" subcommand registered', () => {
-        const names = memoryCommand.commands.map((c) => c.name());
-        expect(names).toContain('remove');
-    });
-
-    it('should have "move" subcommand registered', () => {
-        const names = memoryCommand.commands.map((c) => c.name());
-        expect(names).toContain('move');
-    });
-
-    it('should have "list" subcommand registered', () => {
-        const names = memoryCommand.commands.map((c) => c.name());
-        expect(names).toContain('list');
-    });
-});

package/src/memory/index.ts

@@ -1,44 +0,0 @@
-/**
- * Memory command group for the CLI.
- *
- * This module defines the `memory` command group, which provides operations
- * for managing memories in the Cortex memory system. The `--store` option
- * is defined at the group level and inherited by all subcommands.
- *
- * @example
- * ```bash
- * # Use default store
- * cortex memory add project/notes --content "Hello"
- *
- * # Use specific store
- * cortex memory --store my-store add project/notes --content "Hello"
- * cortex memory -s my-store list
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-
-import { addCommand } from './commands/add.ts';
-import { showCommand } from './commands/show.ts';
-import { updateCommand } from './commands/update.ts';
-import { removeCommand } from './commands/remove.ts';
-import { moveCommand } from './commands/move.ts';
-import { listCommand } from './commands/list.ts';
-
-/**
- * The `memory` command group.
- *
- * Provides memory management operations. The `--store` option allows
- * targeting a specific named store instead of the default store.
- * This option is inherited by all subcommands.
- */
-export const memoryCommand = new Command('memory')
-    .description('Memory operations')
-    .option('-s, --store <name>', 'Use a specific named store');
-
-memoryCommand.addCommand(addCommand);
-memoryCommand.addCommand(showCommand);
-memoryCommand.addCommand(updateCommand);
-memoryCommand.addCommand(removeCommand);
-memoryCommand.addCommand(moveCommand);
-memoryCommand.addCommand(listCommand);

package/src/memory/parsing.spec.ts

@@ -1,105 +0,0 @@
-/**
- * Unit tests for memory/parsing.ts
- *
- * @module cli/memory/parsing.spec
- */
-
-import { describe, it, expect } from 'bun:test';
-import { parseTags, parseExpiresAt } from './parsing';
-import { expectInvalidArgumentError } from '../test-helpers.spec';
-
-// ============================================================================
-// parseTags
-// ============================================================================
-
-describe('parseTags', () => {
-    it('should return empty array for undefined input', () => {
-        expect(parseTags(undefined)).toEqual([]);
-    });
-
-    it('should return empty array for empty array input', () => {
-        expect(parseTags([])).toEqual([]);
-    });
-
-    it('should split comma-separated tags from a single string', () => {
-        expect(parseTags(['foo,bar,baz'])).toEqual([
-            'foo',
-            'bar',
-            'baz',
-        ]);
-    });
-
-    it('should handle multiple string entries in the array', () => {
-        expect(parseTags([
-            'foo', 'bar',
-        ])).toEqual([
-            'foo', 'bar',
-        ]);
-    });
-
-    it('should trim whitespace from each tag', () => {
-        expect(parseTags([' foo , bar , baz '])).toEqual([
-            'foo',
-            'bar',
-            'baz',
-        ]);
-    });
-
-    it('should filter empty strings after splitting and trimming', () => {
-        expect(parseTags([
-            ',,,', '  ,  ',
-        ])).toEqual([]);
-    });
-
-    it('should preserve duplicate tags without deduplication', () => {
-        expect(parseTags([
-            'foo,foo', 'foo',
-        ])).toEqual([
-            'foo',
-            'foo',
-            'foo',
-        ]);
-    });
-});
-
-// ============================================================================
-// parseExpiresAt
-// ============================================================================
-
-describe('parseExpiresAt', () => {
-    it('should return undefined for undefined input', () => {
-        expect(parseExpiresAt(undefined)).toBeUndefined();
-    });
-
-    it('should return undefined for empty string', () => {
-        expect(parseExpiresAt('')).toBeUndefined();
-    });
-
-    it('should return a Date for valid ISO 8601 string', () => {
-        const result = parseExpiresAt('2025-12-31T23:59:59.000Z');
-        expect(result).toBeInstanceOf(Date);
-        expect(result!.toISOString()).toBe('2025-12-31T23:59:59.000Z');
-    });
-
-    it('should return a Date for valid date-only string "2025-12-31"', () => {
-        const result = parseExpiresAt('2025-12-31');
-        expect(result).toBeInstanceOf(Date);
-        expect(result!.getFullYear()).toBe(2025);
-        expect(result!.getMonth()).toBe(11); // 0-indexed December
-        expect(result!.getDate()).toBe(31);
-    });
-
-    it('should throw InvalidArgumentError for invalid date string "not-a-date"', async () => {
-        await expectInvalidArgumentError(
-            () => parseExpiresAt('not-a-date'),
-            'Invalid expiration date format',
-        );
-    });
-
-    it('should throw InvalidArgumentError for garbage string "abc123"', async () => {
-        await expectInvalidArgumentError(
-            () => parseExpiresAt('abc123'),
-            'Invalid expiration date format',
-        );
-    });
-});

package/src/memory/parsing.ts

@@ -1,22 +0,0 @@
-import { throwCliError } from '../errors';
-
-export const parseTags = (raw?: string[]): string[] =>
-    raw
-        ? raw
-            .flatMap((tag) => tag.split(','))
-            .map((tag) => tag.trim())
-            .filter(Boolean)
-        : [];
-
-export const parseExpiresAt = (raw?: string): Date | undefined => {
-    if (!raw) {
-        return undefined;
-    }
-
-    const parsed = new Date(raw);
-    if (Number.isNaN(parsed.getTime())) {
-        throwCliError({ code: 'INVALID_ARGUMENTS', message: 'Invalid expiration date format' });
-    }
-
-    return parsed;
-};

package/src/observability.spec.ts

@@ -1,126 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { createCliLogger } from './observability.ts';
-
-describe('createCliLogger', () => {
-    let stderrLines: string[];
-    let origWrite: typeof process.stderr.write;
-    let origDebugEnv: string | undefined;
-
-    beforeEach(() => {
-        stderrLines = [];
-        origWrite = process.stderr.write.bind(process.stderr);
-        origDebugEnv = process.env.DEBUG;
-        process.stderr.write = ((chunk: string | Uint8Array) => {
-            stderrLines.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString());
-            return true;
-        }) as any;
-    });
-
-    afterEach(() => {
-        process.stderr.write = origWrite;
-        if (origDebugEnv === undefined) {
-            delete process.env.DEBUG;
-        }
-        else {
-            process.env.DEBUG = origDebugEnv;
-        }
-    });
-
-    describe('info()', () => {
-        it('should write human-friendly info log to stderr', () => {
-            const logger = createCliLogger();
-            logger.info('hello world');
-            expect(stderrLines.length).toBe(1);
-            expect(stderrLines[0]).toBe('INFO: hello world\n');
-        });
-
-        it('should include metadata in the log line', () => {
-            const logger = createCliLogger();
-            logger.info('test', { store: 'default', count: 5 });
-            expect(stderrLines[0]).toBe('INFO: test store=default count=5\n');
-        });
-    });
-
-    describe('warn()', () => {
-        it('should write warn log to stderr', () => {
-            const logger = createCliLogger();
-            logger.warn('warning message');
-            expect(stderrLines.length).toBe(1);
-            expect(stderrLines[0]).toBe('WARN: warning message\n');
-        });
-    });
-
-    describe('error()', () => {
-        it('should write error log with Error object details', () => {
-            const logger = createCliLogger();
-            logger.error('something failed', new Error('boom'));
-            expect(stderrLines.length).toBe(1);
-            expect(stderrLines[0]).toBe('ERROR: something failed error=boom\n');
-        });
-
-        it('should handle string error argument', () => {
-            const logger = createCliLogger();
-            logger.error('failed', 'string error');
-            expect(stderrLines[0]).toBe('ERROR: failed error="string error"\n');
-        });
-
-        it('should handle missing error argument', () => {
-            const logger = createCliLogger();
-            logger.error('failed');
-            expect(stderrLines.length).toBe(1);
-            expect(stderrLines[0]).toBe('ERROR: failed\n');
-        });
-    });
-
-    describe('debug()', () => {
-        it('should suppress debug output when DEBUG env is not set', () => {
-            delete process.env.DEBUG;
-            const logger = createCliLogger();
-            logger.debug('debug message');
-            expect(stderrLines.length).toBe(0);
-        });
-
-        it('should write debug output when DEBUG=cortex', () => {
-            process.env.DEBUG = 'cortex';
-            const logger = createCliLogger();
-            logger.debug('debug message');
-            expect(stderrLines.length).toBe(1);
-            expect(stderrLines[0]).toBe('DEBUG: debug message\n');
-        });
-
-        it('should write debug output when DEBUG includes cortex alongside other values', () => {
-            process.env.DEBUG = 'express,cortex,http';
-            const logger = createCliLogger();
-            logger.debug('debug message');
-            expect(stderrLines.length).toBe(1);
-        });
-
-        it('should suppress debug when DEBUG is set to a different value', () => {
-            process.env.DEBUG = 'express';
-            const logger = createCliLogger();
-            logger.debug('debug message');
-            expect(stderrLines.length).toBe(0);
-        });
-    });
-
-    describe('Logger interface compliance', () => {
-        it('should not write to stdout', () => {
-            const stdoutLines: string[] = [];
-            const origStdoutWrite = process.stdout.write.bind(process.stdout);
-            process.stdout.write = ((chunk: string | Uint8Array) => {
-                stdoutLines.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString());
-                return true;
-            }) as any;
-            try {
-                const logger = createCliLogger();
-                logger.info('test');
-                logger.warn('test');
-                logger.error('test');
-                expect(stdoutLines.length).toBe(0);
-            }
-            finally {
-                process.stdout.write = origStdoutWrite;
-            }
-        });
-    });
-});

package/src/observability.ts

@@ -1,82 +0,0 @@
-/**
- * CLI observability — plain ConsoleLogger writing human-readable lines to stderr.
- *
- * No OTel SDK dependency — keeps the CLI binary small.
- * Debug output is gated by the `DEBUG=cortex` environment variable.
- *
- * @module cli/observability
- */
-import type { Logger } from '@yeseh/cortex-core';
-
-/**
- * Creates a plain console logger for CLI usage.
- *
- * Writes human-readable log lines to stderr (not stdout) to avoid
- * polluting piped command output. Debug output is gated by the
- * `DEBUG=cortex` environment variable.
- *
- * @returns Logger instance writing to stderr
- *
- * @example
- * ```typescript
- * const logger = createCliLogger();
- * logger.info('Starting command', { store: 'global' });
- * // → INFO: Starting command store=global
- * ```
- *
- * @example
- * ```bash
- * # Enable debug output
- * DEBUG=cortex cortex memory list
- * ```
- */
-export const createCliLogger = (): Logger => {
-    const debugEnabled =
-        typeof process.env.DEBUG === 'string' && process.env.DEBUG.includes('cortex');
-
-    const stringifyMetaValue = (value: unknown): string => {
-        if (typeof value === 'string') {
-            return value.includes(' ') ? JSON.stringify(value) : value;
-        }
-        if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
-            return String(value);
-        }
-        return JSON.stringify(value);
-    };
-
-    const formatMeta = (meta?: Record<string, unknown>): string => {
-        if (!meta || Object.keys(meta).length === 0) return '';
-        return Object.entries(meta)
-            .map(([key, value]) => `${key}=${stringifyMetaValue(value)}`)
-            .join(' ');
-    };
-
-    const write = (level: string, msg: string, meta?: Record<string, unknown>): void => {
-        const line = `${level.toUpperCase()}: ${msg}`;
-        const metaText = formatMeta(meta);
-        process.stderr.write(metaText.length > 0 ? `${line} ${metaText}\n` : `${line}\n`);
-    };
-
-    return {
-        debug(msg: string, meta?: Record<string, unknown>): void {
-            if (debugEnabled) write('debug', msg, meta);
-        },
-        info(msg: string, meta?: Record<string, unknown>): void {
-            write('info', msg, meta);
-        },
-        warn(msg: string, meta?: Record<string, unknown>): void {
-            write('warn', msg, meta);
-        },
-        error(msg: string, err?: Error | unknown, meta?: Record<string, unknown>): void {
-            const errMeta =
-                err instanceof Error
-                    ? debugEnabled
-                        ? { error: err.message, stack: err.stack }
-                        : { error: err.message }
-                    : err !== null && err !== undefined
-                      ? { error: String(err) }
-                      : {};
-            write('error', msg, { ...meta, ...errMeta });
-        },
-    };
-};