@yeseh/cortex-cli 0.6.8 → 0.6.10

package/src/store/commands/remove.ts

@@ -1,189 +0,0 @@
-/**
- * Store remove command for unregistering a store.
- *
- * This command removes a store from the global registry. Note that this
- * only unregisters the store - it does not delete the actual data.
- *
- * @example
- * ```bash
- * # Remove a store from the registry
- * cortex store remove work
- * ```
- */
-
-import { Command } from '@commander-js/extra-typings';
-import { throwCliError } from '../../errors.ts';
-import { getDefaultConfigPath } from '../../utils/paths.ts';
-import { serializeOutput, type OutputStore, type OutputFormat } from '../../output.ts';
-import { Slug, parseConfig, type CortexContext } from '@yeseh/cortex-core';
-import { createCliCommandContext } from '../../context.ts';
-
-/**
- * Options for the remove command.
- */
-export interface RemoveCommandOptions {
-    /** Output format (yaml, json, toon) */
-    format?: string;
-}
-
-/**
- * Dependencies for the remove command handler.
- * Allows injection for testing.
- */
-export interface RemoveHandlerDeps {
-    /** Output stream for writing results (defaults to process.stdout) */
-    stdout?: NodeJS.WritableStream;
-}
-
-/**
- * Validates store name input.
- *
- * @param name - The raw store name input
- * @returns The validated, trimmed store name
- * @throws {InvalidArgumentError} When the store name is empty or invalid
- */
-function validateStoreName(name: string): string {
-    const slugResult = Slug.from(name);
-    if (!slugResult.ok()) {
-        throwCliError({
-            code: 'INVALID_STORE_NAME',
-            message: 'Store name must be a lowercase slug (letters, numbers, hyphens).',
-        });
-    }
-
-    return slugResult.value.toString();
-}
-
-/**
- * Writes the serialized output to the output stream.
- *
- * @param output - The store output payload
- * @param format - The output format
- * @param stdout - The output stream
- */
-function writeOutput(
-    output: OutputStore,
-    format: OutputFormat,
-    stdout: NodeJS.WritableStream,
-): void {
-    const serialized = serializeOutput({ kind: 'store', value: output }, format);
-    if (!serialized.ok()) {
-        throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
-    }
-    stdout.write(serialized.value + '\n');
-}
-
-/**
- * Handles the remove command execution.
- *
- * This function:
- * 1. Validates the store name format
- * 2. Checks that the store exists in context
- * 3. Reads current config file
- * 4. Removes the store from the config and saves
- * 5. Outputs the result
- *
- * @param ctx - The Cortex context
- * @param name - The store name to unregister
- * @param options - Command options (format)
- * @param deps - Optional dependencies for testing
- * @throws {InvalidArgumentError} When the store name is invalid
- * @throws {CommanderError} When the store doesn't exist or config operations fail
- */
-export async function handleRemove(
-    ctx: CortexContext,
-    name: string,
-    options: RemoveCommandOptions = {},
-    deps: RemoveHandlerDeps = {},
-): Promise<void> {
-    const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
-    const configPath = getDefaultConfigPath();
-
-    // 1. Validate store name
-    const trimmedName = validateStoreName(name);
-
-    // 2. Check if store exists in context
-    const existingStore = ctx.stores[trimmedName];
-    if (!existingStore) {
-        throwCliError({
-            code: 'STORE_NOT_FOUND',
-            message: `Store '${trimmedName}' is not registered.`,
-        });
-    }
-
-    // Get the path from the existing store before removing
-    const storePath = (existingStore.properties as { path: string }).path;
-
-    // 3. Read current config file
-    const configFile = Bun.file(configPath);
-    if (!(await configFile.exists())) {
-        throwCliError({
-            code: 'CONFIG_NOT_FOUND',
-            message: `Config file not found at ${configPath}. Cannot remove store.`,
-        });
-    }
-    let configContents: string;
-    try {
-        configContents = await configFile.text();
-    }
-    catch {
-        throwCliError({
-            code: 'CONFIG_READ_FAILED',
-            message: `Failed to read config at ${configPath}`,
-        });
-    }
-
-    const configResult = parseConfig(configContents);
-    if (!configResult.ok()) {
-        throwCliError(configResult.error);
-    }
-
-    // 4. Remove store from config
-    const { [trimmedName]: _removed, ...remainingStores } = configResult.value.stores ?? {};
-
-    const updatedConfig = {
-        ...configResult.value,
-        stores: remainingStores,
-    };
-
-    // 5. Write updated config
-    const serialized = Bun.YAML.stringify(updatedConfig, null, 2);
-    try {
-        await Bun.write(configPath, serialized);
-    }
-    catch {
-        throwCliError({
-            code: 'CONFIG_WRITE_FAILED',
-            message: `Failed to write config at ${configPath}`,
-        });
-    }
-
-    // 6. Output result
-    const output: OutputStore = { name: trimmedName, path: storePath };
-    const format: OutputFormat = (options.format as OutputFormat) ?? 'yaml';
-    writeOutput(output, format, stdout);
-}
-
-/**
- * The `remove` subcommand for unregistering a store.
- *
- * Removes a store from the registry. This only unregisters the store
- * from the global registry - it does not delete the actual data.
- *
- * @example
- * ```bash
- * cortex store remove work
- * cortex store remove project --format json
- * ```
- */
-export const removeCommand = new Command('remove')
-    .description('Unregister a store from the registry')
-    .argument('<name>', 'Store name to remove')
-    .option('-o, --format <format>', 'Output format (yaml, json, toon)', 'yaml')
-    .action(async (name, options) => {
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
-        }
-        await handleRemove(context.value, name, options);
-    });

package/src/store/index.spec.ts

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

package/src/store/index.ts

@@ -1,49 +0,0 @@
-/**
- * Store command group for the Cortex CLI.
- *
- * Provides store management operations including listing, adding, removing,
- * and initializing memory stores. Also includes maintenance commands for
- * pruning expired memories and reindexing stores.
- *
- * The `--store` option is defined at the group level and inherited by all
- * subcommands, allowing users to specify which store to operate on.
- *
- * @example
- * ```bash
- * cortex store list                 # List all registered stores
- * cortex store add <name> <path>    # Register a store
- * cortex store remove <name>        # Unregister a store
- * cortex store init [path]          # Initialize a new store
- * cortex store prune                # Remove expired memories
- * cortex store reindex              # Rebuild store indexes
- * ```
- */
-import { Command } from '@commander-js/extra-typings';
-
-import { listCommand } from './commands/list.ts';
-import { addCommand } from './commands/add.ts';
-import { removeCommand } from './commands/remove.ts';
-import { initCommand } from './commands/init.ts';
-import { pruneCommand } from './commands/prune.ts';
-import { reindexCommand } from './commands/reindexs.ts';
-
-// Re-export resolveStoreName from its own utility module so callers that
-// previously imported it from this file continue to work.
-export { resolveStoreName } from './utils/resolve-store-name.ts';
-
-/**
- * Store command group.
- *
- * The `--store` option is inherited by all subcommands, allowing operations
- * to target a specific named store rather than using automatic store resolution.
- */
-export const storeCommand = new Command('store')
-    .description('Store management')
-    .option('-s, --store <name>', 'Use a specific named store');
-
-storeCommand.addCommand(listCommand);
-storeCommand.addCommand(addCommand);
-storeCommand.addCommand(removeCommand);
-storeCommand.addCommand(initCommand);
-storeCommand.addCommand(pruneCommand);
-storeCommand.addCommand(reindexCommand);

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

@@ -1,62 +0,0 @@
-import { afterEach, describe, expect, it } from 'bun:test';
-import { InvalidArgumentError } from '@commander-js/extra-typings';
-import { mkdtemp, mkdir, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { basename, join } from 'node:path';
-
-import { runGitCommand } from '../../utils/git.ts';
-import { resolveStoreName } from './resolve-store-name.ts';
-
-const THIS_DIR = import.meta.dir;
-
-describe('resolveStoreName', () => {
-    const createdDirs: string[] = [];
-
-    afterEach(async () => {
-        for (const dir of createdDirs.splice(0)) {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-
-    it('should prioritize explicit name when provided', async () => {
-        const name = await resolveStoreName('/any/path', 'My Project Store!');
-        expect(name).toBe('my-project-store');
-    });
-
-    it('should throw InvalidArgumentError for invalid explicit name', async () => {
-        await expect(resolveStoreName('/any/path', '   ')).rejects.toThrow(InvalidArgumentError);
-    });
-
-    it('should derive store name from git toplevel basename', async () => {
-        const toplevelResult = await runGitCommand([
-            'rev-parse', '--show-toplevel',
-        ], THIS_DIR);
-        if (!toplevelResult.ok) {
-            return;
-        }
-
-        const expected = basename(toplevelResult.value)
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-|-$/g, '');
-
-        const resolved = await resolveStoreName(THIS_DIR);
-        expect(resolved).toBe(expected);
-    });
-
-    it('should fall back to folder basename when not in a git repository', async () => {
-        const dir = await mkdtemp(join(tmpdir(), 'Resolve Name Folder '));
-        createdDirs.push(dir);
-
-        const resolved = await resolveStoreName(dir);
-        expect(resolved).toMatch(/^resolve-name-folder-/);
-    });
-
-    it('should return an empty slug when folder basename normalizes to nothing', async () => {
-        const dir = join(tmpdir(), '!!!');
-        await mkdir(dir, { recursive: true });
-        createdDirs.push(dir);
-
-        await expect(resolveStoreName(dir)).resolves.toBe('');
-    });
-});

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

@@ -1,79 +0,0 @@
-/**
- * Utility for resolving the store name using a priority-based strategy.
- *
- * Extracted into its own module to avoid a circular dependency:
- *   store/commands/init.ts → store/index.ts → store/commands/init.ts
- *
- * @module cli/store/utils/resolve-store-name
- */
-
-import { Slug } from '@yeseh/cortex-core';
-import { basename } from 'node:path';
-import { detectGitRepoName } from '../../utils/git.ts';
-import { throwCliError } from '../../errors.ts';
-
-/**
- * Resolves the store name using a priority-based strategy.
- *
- * Name resolution follows this precedence:
- * 1. **Explicit name** - If `--name` option is provided, use it directly
- * 2. **Git detection** - Auto-detect from git repository directory name
- * 3. **Folder name** - Use the current folder name if git detection fails
- * 4. **Error** - Fail with guidance to use `--name` flag
- *
- * Git repository names are normalized to valid store name format:
- * - Converted to lowercase
- * - Non-alphanumeric characters replaced with hyphens
- * - Leading/trailing hyphens removed
- *
- * @param cwd - Current working directory
- * @param explicitName - Optional explicit name provided via `--name` option
- * @returns The validated store name
- * @throws {InvalidArgumentError} When the name is invalid
- * @throws {CommanderError} When git detection fails and no name provided
- */
-export async function resolveStoreName(cwd: string, explicitName?: string): Promise<string> {
-    // 1. Use explicit name if provided
-    if (explicitName) {
-        const slugResult = Slug.from(explicitName);
-        if (!slugResult.ok()) {
-            throwCliError({
-                code: 'INVALID_STORE_NAME',
-                message: 'Store name must be a lowercase slug (letters, numbers, hyphens).',
-            });
-        }
-
-        return slugResult.value.toString();
-    }
-
-    // 2. Try git detection
-    const gitName = await detectGitRepoName(cwd);
-    if (gitName) {
-        // Convert to valid store name (lowercase slug)
-        const normalized = gitName
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-|-$/g, '');
-        const slugResult = Slug.from(normalized);
-        if (!slugResult.ok()) {
-            throwCliError({
-                code: 'INVALID_STORE_NAME',
-                message: 'Could not derive valid store name from git repo.',
-            });
-        }
-        return slugResult.value.toString();
-    }
-
-    // 3. Use the leaf folder name if git detection fails
-    const folderName = basename(cwd);
-    const slugResult = Slug.from(folderName);
-    if (slugResult.ok()) {
-        return slugResult.value.toString();
-    }
-
-    // 4. Error: require --name
-    throwCliError({
-        code: 'GIT_REPO_REQUIRED',
-        message: 'Not in a git repository. Use --name to specify the store name.',
-    });
-}