@yeseh/cortex-cli 0.6.8 → 0.6.10

package/src/utils/paths.spec.ts

@@ -1,235 +0,0 @@
-/**
- * Unit tests for CLI path resolution utilities.
- *
- * @module cli/paths.spec
- */
-
-import { describe, expect, it } from 'bun:test';
-import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
-
-import { getDefaultConfigPath, getDefaultGlobalStorePath, isAbsolutePath, resolveUserPath } from './paths.ts';
-import { validateStorePath } from '../context.ts';
-
-describe('isAbsolutePath', () => {
-    it('should return true for Unix absolute path starting with /', () => {
-        expect(isAbsolutePath('/home/user/foo')).toBe(true);
-    });
-
-    it('should return true for Unix root path /', () => {
-        expect(isAbsolutePath('/')).toBe(true);
-    });
-
-    it('should return true for Windows drive path C:\\', () => {
-        expect(isAbsolutePath('C:\\Users\\foo')).toBe(true);
-    });
-
-    it('should return true for Windows drive path D:/', () => {
-        expect(isAbsolutePath('D:/Users/foo')).toBe(true);
-    });
-
-    it('should return true for UNC path \\\\server\\share', () => {
-        expect(isAbsolutePath('\\\\server\\share')).toBe(true);
-    });
-
-    it('should return true for UNC path //server/share', () => {
-        expect(isAbsolutePath('//server/share')).toBe(true);
-    });
-
-    it('should return false for relative path ./foo', () => {
-        expect(isAbsolutePath('./foo')).toBe(false);
-    });
-
-    it('should return false for bare filename foo.ts', () => {
-        expect(isAbsolutePath('foo.ts')).toBe(false);
-    });
-
-    it('should return false for relative path ../bar', () => {
-        expect(isAbsolutePath('../bar')).toBe(false);
-    });
-
-    it('should return false for empty string', () => {
-        expect(isAbsolutePath('')).toBe(false);
-    });
-});
-
-describe('resolveUserPath', () => {
-    const cwd = '/some/working/dir';
-
-    it('should expand ~ to homedir', () => {
-        const result = resolveUserPath('~', cwd);
-        expect(result).toBe(homedir());
-    });
-
-    it('should resolve ~/subdir correctly', () => {
-        const result = resolveUserPath('~/subdir', cwd);
-        const expected = `${homedir()}/subdir`;
-        expect(result).toBe(expected);
-    });
-
-    it('should return absolute path unchanged for /abs/path', () => {
-        const result = resolveUserPath('/abs/path', cwd);
-        expect(result).toBe('/abs/path');
-    });
-
-    it('should resolve relative paths against cwd', () => {
-        const result = resolveUserPath('relative/path', cwd);
-        expect(result).toBe('/some/working/dir/relative/path');
-    });
-
-    it('should resolve ./foo relative to cwd', () => {
-        const result = resolveUserPath('./foo', cwd);
-        expect(result).toBe('/some/working/dir/foo');
-    });
-
-    it('should resolve ../bar relative to cwd', () => {
-        const result = resolveUserPath('../bar', cwd);
-        expect(result).toBe('/some/working/bar');
-    });
-
-    it('should return an absolute path for any input', () => {
-        expect(isAbsolute(resolveUserPath('foo', cwd))).toBe(true);
-        expect(isAbsolute(resolveUserPath('~/foo', cwd))).toBe(true);
-        expect(isAbsolute(resolveUserPath('/foo', cwd))).toBe(true);
-    });
-
-    it('should handle ~ with no trailing path', () => {
-        const result = resolveUserPath('~', cwd);
-        expect(result).toBe(homedir());
-    });
-});
-
-describe('validateStorePath', () => {
-    it('should return ok for absolute path', () => {
-        const result = validateStorePath('/absolute/path/to/store', 'my-store');
-        expect(result.ok()).toBe(true);
-    });
-
-    it('should return INVALID_STORE_PATH error for relative path', () => {
-        const result = validateStorePath('relative/path', 'my-store');
-        expect(result.ok()).toBe(false);
-        if (!result.ok()) {
-            expect(result.error.code).toBe('INVALID_STORE_PATH');
-        }
-    });
-
-    it('should return INVALID_STORE_PATH error for empty path', () => {
-        const result = validateStorePath('', 'my-store');
-        expect(result.ok()).toBe(false);
-        if (!result.ok()) {
-            expect(result.error.code).toBe('INVALID_STORE_PATH');
-        }
-    });
-
-    it('should include the store name in the error message', () => {
-        const result = validateStorePath('relative/path', 'cortex-store');
-        expect(result.ok()).toBe(false);
-        if (!result.ok()) {
-            expect(result.error.message).toContain('cortex-store');
-        }
-    });
-
-    it('should return ok for ~ expanded paths that are absolute after resolution', () => {
-        // validateStorePath uses isAbsolute directly - ~ is NOT expanded here
-        // so ~/path is NOT absolute according to isAbsolute
-        const result = validateStorePath('~/memory', 'my-store');
-        expect(result.ok()).toBe(false);
-        if (!result.ok()) {
-            expect(result.error.code).toBe('INVALID_STORE_PATH');
-        }
-    });
-});
-
-describe('getDefaultGlobalStorePath', () => {
-    it('should return an absolute path', () => {
-        const path = getDefaultGlobalStorePath();
-        expect(isAbsolute(path)).toBe(true);
-    });
-
-    it('should end with cortex/memory', () => {
-        const path = getDefaultGlobalStorePath();
-        expect(path.endsWith(join('cortex', 'memory'))).toBe(true);
-    });
-
-    it('should be under the homedir', () => {
-        const path = getDefaultGlobalStorePath();
-        expect(path.startsWith(homedir())).toBe(true);
-    });
-
-    it('should return a consistent value on multiple calls', () => {
-        const first = getDefaultGlobalStorePath();
-        const second = getDefaultGlobalStorePath();
-        expect(first).toBe(second);
-    });
-});
-
-describe('getDefaultConfigPath', () => {
-    it('should return an absolute path', () => {
-        const path = getDefaultConfigPath();
-        expect(isAbsolute(path)).toBe(true);
-    });
-
-    it('should end with cortex/config.yaml', () => {
-        const path = getDefaultConfigPath();
-        expect(path.endsWith(join('cortex', 'config.yaml'))).toBe(true);
-    });
-
-    it('should be under the homedir', () => {
-        const path = getDefaultConfigPath();
-        expect(path.startsWith(homedir())).toBe(true);
-    });
-
-    it('should return a consistent value on multiple calls', () => {
-        const first = getDefaultConfigPath();
-        const second = getDefaultConfigPath();
-        expect(first).toBe(second);
-    });
-
-    it('should prefer CORTEX_CONFIG when set', () => {
-        const previous = process.env.CORTEX_CONFIG;
-        const previousDir = process.env.CORTEX_CONFIG_DIR;
-        process.env.CORTEX_CONFIG = '/tmp/custom-config.yaml';
-        process.env.CORTEX_CONFIG_DIR = '/tmp/ignored-dir';
-
-        const path = getDefaultConfigPath();
-
-        if (previous === undefined) {
-            Reflect.deleteProperty(process.env, 'CORTEX_CONFIG');
-        }
-        else {
-            process.env.CORTEX_CONFIG = previous;
-        }
-        if (previousDir === undefined) {
-            Reflect.deleteProperty(process.env, 'CORTEX_CONFIG_DIR');
-        }
-        else {
-            process.env.CORTEX_CONFIG_DIR = previousDir;
-        }
-
-        expect(path).toBe('/tmp/custom-config.yaml');
-    });
-
-    it('should use CORTEX_CONFIG_DIR when CORTEX_CONFIG is unset', () => {
-        const previous = process.env.CORTEX_CONFIG;
-        const previousDir = process.env.CORTEX_CONFIG_DIR;
-        Reflect.deleteProperty(process.env, 'CORTEX_CONFIG');
-        process.env.CORTEX_CONFIG_DIR = '/tmp/custom-config-dir';
-
-        const path = getDefaultConfigPath();
-
-        if (previous === undefined) {
-            Reflect.deleteProperty(process.env, 'CORTEX_CONFIG');
-        }
-        else {
-            process.env.CORTEX_CONFIG = previous;
-        }
-        if (previousDir === undefined) {
-            Reflect.deleteProperty(process.env, 'CORTEX_CONFIG_DIR');
-        }
-        else {
-            process.env.CORTEX_CONFIG_DIR = previousDir;
-        }
-
-        expect(path).toBe(join('/tmp/custom-config-dir', 'config.yaml'));
-    });
-});

package/src/utils/paths.ts

@@ -1,75 +0,0 @@
-/**
- * Path resolution utilities for CLI commands.
- *
- * Provides cross-platform path handling including:
- * - Home directory (~) expansion
- * - Absolute path detection (Unix, Windows drive, UNC)
- * - Relative path resolution
- */
-
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-
-/**
- * Checks if a path is absolute.
- * Handles Unix paths, Windows drive paths (C:\), and UNC paths (\\server).
- */
-export function isAbsolutePath(inputPath: string): boolean {
-    // Unix absolute path
-    if (inputPath.startsWith('/')) return true;
-    // Windows drive path (e.g., C:\, D:/)
-    if (/^[a-zA-Z]:[/\\]/.test(inputPath)) return true;
-    // UNC path (e.g., \\server\share, //server/share)
-    if (inputPath.startsWith('\\\\') || inputPath.startsWith('//')) return true;
-    return false;
-}
-
-/**
- * Resolves a user-provided path to an absolute path.
- *
- * Handles:
- * - Home directory expansion (~)
- * - Absolute paths (returned as-is, normalized)
- * - Relative paths (resolved against cwd)
- *
- * @param inputPath - The path to resolve
- * @param cwd - Current working directory for relative path resolution
- * @returns Normalized absolute path
- */
-export function resolveUserPath(inputPath: string, cwd: string): string {
-    // Expand home directory
-    if (inputPath.startsWith('~')) {
-        const home = homedir();
-        return resolve(home, inputPath.slice(1).replace(/^[/\\]/, ''));
-    }
-    // Already absolute
-    if (isAbsolutePath(inputPath)) {
-        return resolve(inputPath);
-    }
-    // Relative to cwd
-    return resolve(cwd, inputPath);
-}
-
-/**
- * Default path to the global store.
- */
-export const getDefaultGlobalStorePath = (): string =>
-    resolve(homedir(), '.config', 'cortex', 'memory');
-
-/**
- * Default path to the store configuration file.
- * Respects CORTEX_CONFIG (config file path) and CORTEX_CONFIG_DIR (config directory)
- * environment variables when set.
- */
-export const getDefaultConfigPath = (): string => {
-    const envConfigPath = process.env.CORTEX_CONFIG;
-    if (envConfigPath) {
-        return resolve(envConfigPath);
-    }
-
-    const envConfigDir = process.env.CORTEX_CONFIG_DIR;
-    if (envConfigDir) {
-        return resolve(envConfigDir, 'config.yaml');
-    }
-    return resolve(homedir(), '.config', 'cortex', 'config.yaml');
-};

package/src/utils/prompts.spec.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { isTTY } from './prompts.ts';
-
-describe('isTTY', () => {
-    it('should return true when stream.isTTY is true', () => {
-        const stream = { isTTY: true } as unknown as NodeJS.ReadStream;
-        expect(isTTY(stream)).toBe(true);
-    });
-
-    it('should return false when stream.isTTY is false', () => {
-        const stream = { isTTY: false } as unknown as NodeJS.ReadStream;
-        expect(isTTY(stream)).toBe(false);
-    });
-
-    it('should return false when stream.isTTY is undefined', () => {
-        const stream = {} as unknown as NodeJS.ReadStream;
-        expect(isTTY(stream)).toBe(false);
-    });
-
-    it('should return false when stream is undefined', () => {
-        expect(isTTY(undefined)).toBe(false);
-    });
-});

package/src/utils/prompts.ts

@@ -1,88 +0,0 @@
-/**
- * Shared prompt utilities for interactive CLI commands.
- *
- * Provides TTY detection and injectable prompt dependencies (`PromptDeps`) so
- * command handlers remain fully testable without spawning real terminals.
- *
- * Interactive mode activates automatically when stdin is a TTY (same heuristic
- * as git and npm). In non-TTY environments (CI, pipes, scripts) the prompts are
- * simply skipped.
- *
- * @module cli/prompts
- */
-
-import { input, confirm } from '@inquirer/prompts';
-
-/**
- * Async function that prompts the user for a text value.
- *
- * @param opts - Prompt options
- * @param opts.message - The prompt message displayed to the user
- * @param opts.default - The default value shown in the prompt
- * @returns A promise resolving to the user's input or the default
- */
-export type InputFn = (opts: { message: string; default?: string }) => Promise<string>;
-
-/**
- * Async function that prompts the user for a boolean confirmation.
- *
- * @param opts - Prompt options
- * @param opts.message - The prompt message displayed to the user
- * @param opts.default - The default answer (true = yes, false = no)
- * @returns A promise resolving to the user's answer
- */
-export type ConfirmFn = (opts: { message: string; default?: boolean }) => Promise<boolean>;
-
-/**
- * Injectable dependencies for interactive prompts.
- *
- * Pass real functions (from `@inquirer/prompts`) in production and stub
- * implementations in tests to avoid blocking on terminal input.
- *
- * @example
- * ```typescript
- * // Production
- * const deps = defaultPromptDeps;
- *
- * // Test stub
- * const deps: PromptDeps = {
- *     input: async ({ default: d }) => d ?? 'test-value',
- *     confirm: async () => true,
- * };
- * ```
- */
-export interface PromptDeps {
-    input: InputFn;
-    confirm: ConfirmFn;
-}
-
-/**
- * Default prompt dependencies backed by `@inquirer/prompts`.
- * Use this in production; inject stubs in tests.
- */
-export const defaultPromptDeps: PromptDeps = { input, confirm };
-
-/**
- * Checks whether the given readable stream is an interactive terminal (TTY).
- *
- * Returns `true` only when `stream.isTTY === true`. Returns `false` for:
- * - `undefined` stream
- * - streams without an `isTTY` property (e.g. `PassThrough`)
- * - streams where `isTTY` is `false`
- *
- * This mirrors the same heuristic used by git and npm for auto-detecting
- * interactive mode.
- *
- * @param stream - The readable stream to check (usually `ctx.stdin`)
- * @returns `true` if the stream is a TTY, `false` otherwise
- *
- * @example
- * ```typescript
- * if (isTTY(ctx.stdin)) {
- *     // Show interactive prompts
- * }
- * ```
- */
-export function isTTY(stream: NodeJS.ReadableStream | undefined): boolean {
-    return (stream as NodeJS.ReadStream | undefined)?.isTTY === true;
-}

package/src/utils/resolve-default-store.spec.ts

@@ -1,135 +0,0 @@
-/**
- * Tests for resolveDefaultStore utility.
- *
- * @module cli/utils/resolve-default-store.spec
- */
-
-import { describe, it, expect } from 'bun:test';
-import { resolveDefaultStore } from './resolve-default-store.ts';
-import type { CortexContext } from '@yeseh/cortex-core';
-
-// Minimal mock context factory
-function makeCtx(
-    overrides: {
-        cwd?: string;
-        stores?: Record<string, { properties?: Record<string, unknown> }>;
-        defaultStore?: string;
-    } = {},
-): CortexContext {
-    return {
-        cwd: overrides.cwd ?? '/home/user/myproject',
-        stores: (overrides.stores ?? {}) as CortexContext['stores'],
-        settings: { defaultStore: overrides.defaultStore },
-        cortex: {} as CortexContext['cortex'],
-        config: {} as CortexContext['config'],
-        now: () => new Date(),
-        stdin: process.stdin,
-        stdout: process.stdout,
-    };
-}
-
-describe('resolveDefaultStore', () => {
-    it('should return explicit store when provided', () => {
-        const ctx = makeCtx({ stores: { mystore: { properties: { path: '/some/path' } } } });
-        expect(resolveDefaultStore(ctx, 'mystore')).toBe('mystore');
-    });
-
-    it('should return explicit store even when a local store exists', () => {
-        const ctx = makeCtx({
-            cwd: '/home/user/myproject',
-            stores: {
-                local: { properties: { path: '/home/user/myproject/.cortex' } },
-            },
-        });
-        expect(resolveDefaultStore(ctx, 'explicit')).toBe('explicit');
-    });
-
-    it('should auto-detect local store whose path matches <cwd>/.cortex', () => {
-        const ctx = makeCtx({
-            cwd: '/home/user/myproject',
-            stores: {
-                global: { properties: { path: '/home/user/.config/cortex/memory' } },
-                myproject: { properties: { path: '/home/user/myproject/.cortex' } },
-            },
-        });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('myproject');
-    });
-
-    it('should auto-detect local store whose path matches <cwd>/.cortex/memory', () => {
-        const ctx = makeCtx({
-            cwd: '/home/user/myproject',
-            stores: {
-                global: { properties: { path: '/home/user/.config/cortex/memory' } },
-                myproject: { properties: { path: '/home/user/myproject/.cortex/memory' } },
-            },
-        });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('myproject');
-    });
-
-    it('should not match a store whose path only starts with cwd (not an exact .cortex path)', () => {
-        // e.g. cwd is /home/user/proj and a store has /home/user/proj-other/.cortex
-        const ctx = makeCtx({
-            cwd: '/home/user/proj',
-            stores: {
-                other: { properties: { path: '/home/user/proj-other/.cortex' } },
-                global: { properties: { path: '/home/user/.config/cortex/memory' } },
-            },
-            defaultStore: 'global',
-        });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('global');
-    });
-
-    it('should fall back to settings.defaultStore when no local store matches', () => {
-        const ctx = makeCtx({
-            cwd: '/home/user/myproject',
-            stores: {
-                custom: { properties: { path: '/data/custom' } },
-            },
-            defaultStore: 'custom',
-        });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('custom');
-    });
-
-    it('should fall back to "global" when no local store and no defaultStore', () => {
-        const ctx = makeCtx({
-            cwd: '/home/user/myproject',
-            stores: {
-                other: { properties: { path: '/data/other' } },
-            },
-        });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('global');
-    });
-
-    it('should fall back to "global" when stores is empty', () => {
-        const ctx = makeCtx({ cwd: '/home/user/myproject', stores: {} });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('global');
-    });
-
-    it('should handle stores with missing properties gracefully', () => {
-        const ctx = makeCtx({
-            cwd: '/home/user/myproject',
-            stores: {
-                broken: {} as { properties?: Record<string, unknown> },
-            },
-        });
-        expect(resolveDefaultStore(ctx, undefined)).toBe('global');
-    });
-
-    it('should use process.cwd() when ctx.cwd is not set', () => {
-        // Build a ctx with no cwd — store path matches process.cwd()
-        const cwd = process.cwd();
-        const ctx = {
-            stores: {
-                local: { properties: { path: `${cwd}/.cortex` } },
-            } as unknown as CortexContext['stores'],
-            settings: {},
-            cortex: {} as CortexContext['cortex'],
-            config: {} as CortexContext['config'],
-            now: () => new Date(),
-            stdin: process.stdin,
-            stdout: process.stdout,
-            // cwd intentionally omitted
-        } as CortexContext;
-        expect(resolveDefaultStore(ctx, undefined)).toBe('local');
-    });
-});

package/src/utils/resolve-default-store.ts

@@ -1,74 +0,0 @@
-/**
- * Utility for resolving which store to target when no `--store` flag is given.
- *
- * Resolution order (first match wins):
- * 1. Explicit store name provided by the caller (from `--store` flag)
- * 2. Local store – a registered store whose path starts with `<cwd>/.cortex`
- * 3. `settings.defaultStore` from the Cortex config file
- * 4. Hard-coded fallback: `"global"`
- *
- * @module cli/utils/resolve-default-store
- *
- * @example
- * ```typescript
- * // In a command handler:
- * const storeName = resolveDefaultStore(ctx, parentOpts?.store);
- * const storeResult = ctx.cortex.getStore(storeName);
- * ```
- */
-
-import { join } from 'node:path';
-import type { CortexContext } from '@yeseh/cortex-core';
-
-/**
- * Resolves the effective store name for a command invocation.
- *
- * When a user runs a command without `--store` in a project directory where
- * they have run `cortex store init`, the local store registered for that
- * directory is automatically selected so they don't have to type `--store`
- * on every command.
- *
- * @param ctx - The current Cortex context (provides `stores`, `settings`, `cwd`)
- * @param explicit - Store name from the `--store` CLI flag (may be undefined)
- * @returns The resolved store name to use
- *
- * @example
- * ```typescript
- * // No --store flag, inside /home/user/my-project with a .cortex store:
- * resolveDefaultStore(ctx, undefined);
- * // → "my-project"  (the store registered at /home/user/my-project/.cortex)
- *
- * // Explicit flag always wins:
- * resolveDefaultStore(ctx, "global");
- * // → "global"
- * ```
- */
-export function resolveDefaultStore(ctx: CortexContext, explicit: string | undefined): string {
-    // 1. Explicit --store flag wins
-    if (explicit) return explicit;
-
-    const cwd = ctx.cwd ?? process.cwd();
-    const stores = ctx.stores ?? {};
-
-    // 2. Local store – registered store whose path is the `.cortex` dir in cwd
-    //    Both `.cortex` and `.cortex/memory` are accepted to handle both
-    //    naming conventions in use across the project.
-    const localPaths = [
-        join(cwd, '.cortex'), join(cwd, '.cortex', 'memory'),
-    ];
-    for (const [
-        name, store,
-    ] of Object.entries(stores)) {
-        const storePath = store.properties?.path as string | undefined;
-        if (storePath && localPaths.includes(storePath)) {
-            return name;
-        }
-    }
-
-    // 3. settings.defaultStore from config
-    const defaultStore = ctx.settings?.defaultStore;
-    if (defaultStore) return defaultStore;
-
-    // 4. Hard-coded fallback
-    return 'global';
-}