@yeseh/cortex-cli 0.6.0 → 0.6.3

package/src/store/commands/prune.ts

@@ -23,6 +23,7 @@ import { Command } from '@commander-js/extra-typings';
 import { throwCliError } from '../../errors.ts';
 import { type CortexContext } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /**
  * Options for the prune command.
@@ -83,13 +84,13 @@ export async function handlePrune(
     ctx: CortexContext,
     storeName: string | undefined,
     options: PruneCommandOptions,
-    deps: PruneHandlerDeps = {},
+    deps: PruneHandlerDeps = {}
 ): Promise<void> {
     const now = deps.now ?? ctx.now();
     const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
 
     // Get store through Cortex client
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }
@@ -121,8 +122,7 @@ export async function handlePrune(
     const paths = pruned.map((entry) => entry.path).join('\n  ');
     if (options.dryRun) {
         stdout.write(`Would prune ${pruned.length} expired memories:\n  ${paths}\n`);
-    }
-    else {
+    } else {
         stdout.write(`Pruned ${pruned.length} expired memories:\n  ${paths}\n`);
     }
 }

package/src/store/commands/reindexs.ts

@@ -18,6 +18,7 @@ import { Command } from '@commander-js/extra-typings';
 import { throwCliError } from '../../errors.ts';
 import { type CortexContext } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /**
  * Dependencies for the reindex command handler.
@@ -45,12 +46,12 @@ export interface ReindexHandlerDeps {
 export async function handleReindex(
     ctx: CortexContext,
     storeName: string | undefined,
-    deps: ReindexHandlerDeps = {},
+    deps: ReindexHandlerDeps = {}
 ): Promise<void> {
     const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
-    
+
     // Get store through Cortex client
-    const effectiveStoreName = storeName ?? 'global';
+    const effectiveStoreName = resolveDefaultStore(ctx, storeName);
     const storeResult = ctx.cortex.getStore(effectiveStoreName);
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);

package/src/tests/cli.integration.spec.ts

@@ -1167,4 +1167,140 @@ describe('Cortex CLI Integration Tests', () => {
             expect(result.stdout).toContain('reindex');
         });
     });
+
+    describe('store init command', () => {
+        it('should initialize a new store when no store is configured', async () => {
+            // Create an isolated directory with no pre-configured stores — the
+            // config.yaml exists but has no store entries, simulating a fresh install.
+            const freshDir = await fs.mkdtemp(join(tmpdir(), 'cortex-store-init-'));
+            const configDir = join(freshDir, '.config', 'cortex');
+            await fs.mkdir(configDir, { recursive: true });
+            await fs.writeFile(join(configDir, 'config.yaml'), 'stores: {}\n', 'utf8');
+
+            const storePath = join(freshDir, '.cortex', 'memory');
+
+            try {
+                const result = await runCortexCli(
+                    [
+                        'store',
+                        'init',
+                        storePath,
+                        '--name',
+                        'my-project',
+                        '--format',
+                        'json',
+                    ],
+                    {
+                        cwd: freshDir,
+                        env: { CORTEX_CONFIG_DIR: configDir },
+                    },
+                );
+
+                expectCliOk([
+                    'store',
+                    'init',
+                    storePath,
+                    '--name',
+                    'my-project',
+                ], result);
+                expect(result.exitCode).toBe(0);
+
+                const parsed = JSON.parse(result.stdout) as {
+                    value: { name: string; path: string };
+                };
+                expect(parsed.value.name).toBe('my-project');
+                expect(parsed.value.path).toBe(storePath);
+
+                // Verify the store was registered in config.yaml
+                const configContent = await fs.readFile(join(configDir, 'config.yaml'), 'utf8');
+                expect(configContent).toContain('my-project');
+                expect(configContent).toContain(storePath);
+            }
+            finally {
+                await fs.rm(freshDir, { recursive: true, force: true });
+            }
+        });
+
+        it('should create the store directory when it does not yet exist', async () => {
+            const freshDir = await fs.mkdtemp(join(tmpdir(), 'cortex-store-init-newdir-'));
+            const configDir = join(freshDir, '.config', 'cortex');
+            await fs.mkdir(configDir, { recursive: true });
+            await fs.writeFile(join(configDir, 'config.yaml'), 'stores: {}\n', 'utf8');
+
+            // Point at a path that does NOT yet exist on disk
+            const storePath = join(freshDir, 'brand-new-store');
+
+            try {
+                const result = await runCortexCli(
+                    [
+                        'store',
+                        'init',
+                        storePath,
+                        '--name',
+                        'new-dir-store',
+                        '--format',
+                        'json',
+                    ],
+                    {
+                        cwd: freshDir,
+                        env: { CORTEX_CONFIG_DIR: configDir },
+                    },
+                );
+
+                expectCliOk([
+                    'store',
+                    'init',
+                    storePath,
+                    '--name',
+                    'new-dir-store',
+                ], result);
+
+                // The directory must have been created by the init command
+                const dirStat = await fs.stat(storePath);
+                expect(dirStat.isDirectory()).toBe(true);
+            }
+            finally {
+                await fs.rm(freshDir, { recursive: true, force: true });
+            }
+        });
+
+        it('should fail when the store name already exists', async () => {
+            // Register a store first using the existing testProject setup
+            const storePath = join(testProject, '.cortex', 'memory2');
+            const firstInit = await runCortexCli(
+                [
+                    'store',
+                    'init',
+                    storePath,
+                    '--name',
+                    'existing-store',
+                    '--format',
+                    'json',
+                ],
+                { cwd: testProject },
+            );
+            expectCliOk([
+                'store',
+                'init',
+                storePath,
+                '--name',
+                'existing-store',
+            ], firstInit);
+
+            // Attempt to init the same name again — should fail
+            const secondInit = await runCortexCli(
+                [
+                    'store',
+                    'init',
+                    join(testProject, '.cortex', 'memory3'),
+                    '--name',
+                    'existing-store',
+                ],
+                { cwd: testProject },
+            );
+
+            expect(secondInit.exitCode).toBe(1);
+            expect(secondInit.stderr.toLowerCase()).toMatch(/already exists/);
+        });
+    });
 });

package/src/utils/input.ts

@@ -49,7 +49,7 @@ type InputResult = Result<InputContent, InputError>;
 type OptionalContentResult = Result<InputContent | null, InputError>;
 
 export const readContentFromFile = async (
-    filePath: string | undefined
+    filePath: string | undefined,
 ): Promise<OptionalContentResult> => {
     if (filePath === undefined) {
         return ok(null);
@@ -64,7 +64,8 @@ export const readContentFromFile = async (
     try {
         const content = await readFile(trimmed, 'utf8');
         return ok({ content, source: 'file' });
-    } catch (error) {
+    }
+    catch (error) {
         return err({
             code: 'FILE_READ_FAILED',
             message: `Failed to read content file: ${trimmed}.`,
@@ -75,7 +76,7 @@ export const readContentFromFile = async (
 };
 
 export const readContentFromStream = async (
-    stream: NodeJS.ReadableStream
+    stream: NodeJS.ReadableStream,
 ): Promise<OptionalContentResult> => {
     const isTty = 'isTTY' in stream ? Boolean(stream.isTTY) : false;
     if (isTty) {
@@ -110,7 +111,11 @@ export const resolveInput = async (source: InputSource): Promise<InputResult> =>
         source.stream !== undefined &&
         !('isTTY' in source.stream && Boolean((source.stream as { isTTY?: boolean }).isTTY));
 
-    const requestedSources = [contentProvided, fileProvided, streamRequested].filter(Boolean);
+    const requestedSources = [
+        contentProvided,
+        fileProvided,
+        streamRequested,
+    ].filter(Boolean);
 
     if (requestedSources.length > 1) {
         return err({

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

@@ -0,0 +1,135 @@
+/**
+ * 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

@@ -0,0 +1,74 @@
+/**
+ * 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';
+}

package/dist/category/commands/create.d.ts

@@ -1,44 +0,0 @@
-/**
- * Category create command.
- *
- * Creates a category at the specified path, including any missing ancestors.
- *
- * @example
- * ```bash
- * # Create a category in default store
- * cortex category create standards/typescript
- *
- * # Create a category in a specific store
- * cortex category --store my-store create standards/typescript
- *
- * # Serialize output as JSON
- * cortex category create standards --format json
- * ```
- */
-import { Command } from '@commander-js/extra-typings';
-import { type CortexContext } from '@yeseh/cortex-core';
-/** Options parsed by Commander for the create command */
-export interface CreateCommandOptions {
-    description?: string;
-    format?: string;
-}
-/**
- * Handler for the category create command.
- * Exported for direct testing without Commander parsing.
- *
- * @param ctx - CLI execution context
- * @param storeName - Optional store name from parent command
- * @param path - Category path (e.g., "standards/typescript")
- * @param options - Command options from Commander
- */
-export declare function handleCreate(ctx: CortexContext, storeName: string | undefined, path: string, options?: CreateCommandOptions): Promise<void>;
-/**
- * The `category create` subcommand.
- *
- * Creates a category and any missing ancestors.
- */
-export declare const createCommand: Command<[string], {
-    description?: string | undefined;
-    format?: string | undefined;
-}, {}>;
-//# sourceMappingURL=create.d.ts.map

package/dist/category/commands/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/category/commands/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAMxD,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAC9B,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,oBAAyB,GACnC,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;MAapB,CAAC"}

package/dist/category/commands/create.spec.d.ts

@@ -1,7 +0,0 @@
-/**
- * Unit tests for the handleCreate command handler.
- *
- * @module cli/category/commands/create.spec
- */
-export {};
-//# sourceMappingURL=create.spec.d.ts.map

package/dist/category/commands/create.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.spec.d.ts","sourceRoot":"","sources":["../../../src/category/commands/create.spec.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/category/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * Category command group for the CLI.
- *
- * This module defines the `category` command group, which provides operations
- * for managing categories in the Cortex memory system. The `--store` option
- * is defined at the group level and inherited by all subcommands.
- */
-import { Command } from '@commander-js/extra-typings';
-/**
- * The `category` command group.
- *
- * Provides category management operations. The `--store` option allows
- * targeting a specific named store instead of the default store.
- * This option is inherited by all subcommands.
- */
-export declare const categoryCommand: Command<[], {
-    store?: string | undefined;
-}, {}>;
-//# sourceMappingURL=index.d.ts.map

package/dist/category/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/category/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAItD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;MAEmC,CAAC"}

package/dist/commands/init.d.ts

@@ -1,58 +0,0 @@
-/**
- * Init command for initializing the global cortex configuration store.
- *
- * Creates the global config store at ~/.config/cortex/ with:
- * - config.yaml: Global configuration with default settings
- * - stores.yaml: Store registry with a 'default' store pointing to the memory directory
- * - memory/: Default store with 'global' and 'projects' categories
- *
- * @example
- * ```bash
- * # Initialize global cortex configuration
- * cortex init
- *
- * # Reinitialize even if already initialized
- * cortex init --force
- * ```
- */
-import { Command } from '@commander-js/extra-typings';
-import { type CortexContext } from '@yeseh/cortex-core';
-/**
- * Options for the init command.
- */
-export interface InitCommandOptions {
-    /** Reinitialize even if already initialized */
-    force?: boolean;
-    /** Output format (yaml, json, toon) */
-    format?: string;
-}
-/**
- * The `init` command for initializing the global cortex configuration.
- *
- * Creates the global config store at ~/.config/cortex/ with default settings
- * and store registry.
- *
- * @example
- * ```bash
- * cortex init              # Initialize global config
- * cortex init --force      # Reinitialize even if exists
- * ```
- */
-export declare const initCommand: Command<[], {
-    force?: true | undefined;
-    format: string;
-}, {}>;
-/**
- * Handles the init command execution.
- *
- * This function:
- * 1. Initializes the global cortex config store
- * 2. Creates default categories
- * 3. Outputs the result
- *
- * @param options - Command options (force, format)
- * @throws {InvalidArgumentError} When arguments are invalid
- * @throws {CommanderError} When initialization fails
- */
-export declare function handleInit(ctx: CortexContext, options?: InitCommandOptions): Promise<void>;
-//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAStD,OAAO,EAIH,KAAK,aAAa,EAErB,MAAM,oBAAoB,CAAC;AAG5B;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,+CAA+C;IAC/C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW;;;MAalB,CAAC;AAEP;;;;;;;;;;;GAWG;AAIH,wBAAsB,UAAU,CAC5B,GAAG,EAAE,aAAa,EAClB,OAAO,GAAE,kBAAuB,GACjC,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/commands/init.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=init.spec.d.ts.map

package/dist/commands/init.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.spec.d.ts","sourceRoot":"","sources":["../../src/commands/init.spec.ts"],"names":[],"mappings":""}

package/dist/context.d.ts

@@ -1,18 +0,0 @@
-/**
- * Store resolution utilities for CLI commands.
- *
- * This module provides functions to resolve the store context (root directory)
- * based on command-line options, current working directory, and the global
- * store configuration.
- */
-/**
- * Default path to the global store.
- */
-export declare const getDefaultGlobalStorePath: () => string;
-/**
- * Default path to the store configuration file.
- * Respects CORTEX_CONFIG (config file path) and CORTEX_CONFIG_DIR (config directory)
- * environment variables when set.
- */
-export declare const getDefaultConfigPath: () => string;
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;GAEG;AACH,eAAO,MAAM,yBAAyB,QAAO,MACQ,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAWvC,CAAC"}

package/dist/context.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=context.spec.d.ts.map

package/dist/context.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.spec.d.ts","sourceRoot":"","sources":["../src/context.spec.ts"],"names":[],"mappings":""}

package/dist/create-cli-command.d.ts

@@ -1,23 +0,0 @@
-import { getDefaultSettings, type ConfigValidationError, type CortexContext, type Result } from '@yeseh/cortex-core';
-import { FilesystemStorageAdapter, FilesystemConfigAdapter } from '@yeseh/cortex-storage-fs';
-export declare const validateStorePath: (storePath: string, storeName: string) => Result<void, ConfigValidationError>;
-export interface ConfigLoadOptions {
-    cwd?: string;
-    globalConfigPath?: string;
-    localConfigPath?: string;
-}
-export interface CliContextOptions {
-    configDir?: string;
-    configCwd?: string;
-}
-export interface CliConfigContext {
-    configAdapter: FilesystemConfigAdapter;
-    stores: Record<string, any>;
-    settings: ReturnType<typeof getDefaultSettings>;
-    effectiveCwd: string;
-}
-export declare const createCliConfigAdapter: (configPath: string) => FilesystemConfigAdapter;
-export declare const createCliAdapterFactory: (configAdapter: FilesystemConfigAdapter) => (storeName: string) => FilesystemStorageAdapter;
-export declare const createCliConfigContext: (options?: CliContextOptions) => Promise<Result<CliConfigContext, any>>;
-export declare const createCliCommandContext: (configDir?: string) => Promise<Result<CortexContext, any>>;
-//# sourceMappingURL=create-cli-command.d.ts.map

package/dist/create-cli-command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-cli-command.d.ts","sourceRoot":"","sources":["../src/create-cli-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,kBAAkB,EAElB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAY7F,eAAO,MAAM,iBAAiB,GAC1B,WAAW,MAAM,EACjB,WAAW,MAAM,KAClB,MAAM,CAAC,IAAI,EAAE,qBAAqB,CAWpC,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC7B,aAAa,EAAE,uBAAuB,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,QAAQ,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAChD,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,sBAAsB,GAAI,YAAY,MAAM,KAAG,uBAE3D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,eAAe,uBAAuB,MAClE,WAAW,MAAM,6BAkB5B,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAC/B,UAAS,iBAAsB,KAChC,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAC,CA0CvC,CAAC;AAKF,eAAO,MAAM,uBAAuB,GAChC,YAAY,MAAM,KACnB,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,CAoCpC,CAAC"}