@yeseh/cortex-cli 0.6.7 → 0.6.9

package/src/utils/git.spec.ts

@@ -1,95 +0,0 @@
-/**
- * Unit tests for utils/git.ts
- *
- * @module cli/utils/git.spec
- */
-
-import { describe, it, expect, afterEach } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join, basename } from 'node:path';
-import { tmpdir } from 'node:os';
-import { runGitCommand, detectGitRepoName } from './git';
-
-// The spec file lives inside a git worktree — use its own directory as a real
-// git repo for tests that require one.
-const THIS_DIR = import.meta.dir;
-
-// ============================================================================
-// Temp dir management
-// ============================================================================
-
-let tempDirs: string[] = [];
-
-async function makeTempDir(): Promise<string> {
-    const dir = await mkdtemp(join(tmpdir(), 'cortex-git-test-'));
-    tempDirs.push(dir);
-    return dir;
-}
-
-afterEach(async () => {
-    for (const dir of tempDirs) {
-        await rm(dir, { recursive: true, force: true });
-    }
-    tempDirs = [];
-});
-
-// ============================================================================
-// runGitCommand
-// ============================================================================
-
-describe('runGitCommand', () => {
-    it('should return ok with stdout for a valid git command', async () => {
-        const result = await runGitCommand([
-            'rev-parse', '--show-toplevel',
-        ], THIS_DIR);
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(typeof result.value).toBe('string');
-            expect(result.value.length).toBeGreaterThan(0);
-        }
-    });
-
-    it('should return {ok: false} for an invalid git command', async () => {
-        const result = await runGitCommand(['not-a-real-subcommand-xyz'], THIS_DIR);
-        expect(result.ok).toBe(false);
-    });
-
-    it('should return {ok: false} in a non-git directory', async () => {
-        const nonGitDir = await makeTempDir();
-        const result = await runGitCommand([
-            'rev-parse', '--show-toplevel',
-        ], nonGitDir);
-        expect(result.ok).toBe(false);
-    });
-});
-
-// ============================================================================
-// detectGitRepoName
-// ============================================================================
-
-describe('detectGitRepoName', () => {
-    it('should return a non-empty string for a git repo', async () => {
-        const name = await detectGitRepoName(THIS_DIR);
-        expect(typeof name).toBe('string');
-        expect((name ?? '').length).toBeGreaterThan(0);
-    });
-
-    it('should return the toplevel directory basename for a git repo', async () => {
-        // Get the toplevel via git, then compare what detectGitRepoName returns
-        const toplevelResult = await runGitCommand([
-            'rev-parse', '--show-toplevel',
-        ], THIS_DIR);
-        expect(toplevelResult.ok).toBe(true);
-        if (toplevelResult.ok) {
-            const expectedName = basename(toplevelResult.value);
-            const name = await detectGitRepoName(THIS_DIR);
-            expect(name).toBe(expectedName);
-        }
-    });
-
-    it('should return null for a non-git directory', async () => {
-        const nonGitDir = await makeTempDir();
-        const name = await detectGitRepoName(nonGitDir);
-        expect(name).toBeNull();
-    });
-});

package/src/utils/git.ts

@@ -1,51 +0,0 @@
-import { spawn } from 'node:child_process';
-import { basename } from 'node:path';
-
-/**
- * Executes a git command and returns the trimmed stdout.
- */
-export const runGitCommand = (
-    args: string[],
-    cwd: string,
-): Promise<{ ok: true; value: string } | { ok: false }> => {
-    return new Promise((resolvePromise) => {
-        const proc = spawn('git', args, { cwd });
-        let stdout = '';
-
-        proc.stdout.on('data', (data: Buffer) => {
-            stdout += data.toString();
-        });
-        proc.on('close', (code: number | null) => {
-            if (code === 0) {
-                resolvePromise({ ok: true, value: stdout.trim() });
-            }
-            else {
-                resolvePromise({ ok: false });
-            }
-        });
-        proc.on('error', () => {
-            resolvePromise({ ok: false });
-        });
-    });
-};
-
-/**
- * Detects the git repository name from the current working directory.
- *
- * Uses `git rev-parse --show-toplevel` to find the repository root,
- * then extracts the directory name as the repository name.
- *
- * @param cwd - The current working directory to check for git repository
- * @returns The repository directory name, or `null` if not in a git repository
- */
-export const detectGitRepoName = async (cwd: string): Promise<string | null> => {
-    const result = await runGitCommand([
-        'rev-parse', '--show-toplevel',
-    ], cwd);
-    if (!result.ok) {
-        return null;
-    }
-    return basename(result.value);
-};
-
-

package/src/utils/input.spec.ts

@@ -1,326 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import * as fs from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Readable } from 'node:stream';
-
-import { resolveInput } from './input.ts';
-
-const createMockStdin = (data: string, isTTY = false): NodeJS.ReadableStream => {
-    const stream = Readable.from([data]) as NodeJS.ReadableStream & { isTTY?: boolean };
-    stream.isTTY = isTTY;
-    return stream;
-};
-
-describe('resolveMemoryContentInput', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(join(tmpdir(), 'cortex-input-'));
-    });
-
-    afterEach(async () => {
-        if (tempDir) {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-    });
-
-    describe('content flag', () => {
-        it('should return content from --content flag', async () => {
-            const result = await resolveInput({
-                content: 'Hello, world!',
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('Hello, world!');
-                expect(result.value.source).toBe('flag');
-            }
-        });
-
-        it('should return empty string when content is empty', async () => {
-            const result = await resolveInput({
-                content: '',
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('');
-                expect(result.value.source).toBe('flag');
-            }
-        });
-    });
-
-    describe('file input', () => {
-        it('should read content from file', async () => {
-            const filePath = join(tempDir, 'input.txt');
-            await fs.writeFile(filePath, 'File content here');
-
-            const result = await resolveInput({
-                filePath,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('File content here');
-                expect(result.value.source).toBe('file');
-            }
-        });
-
-        it('should return error for non-existent file', async () => {
-            const result = await resolveInput({
-                filePath: join(tempDir, 'nonexistent.txt'),
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('FILE_READ_FAILED');
-                expect(result.error.path).toContain('nonexistent.txt');
-            }
-        });
-
-        it('should return error for empty file path', async () => {
-            const result = await resolveInput({
-                filePath: '   ',
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('INVALID_FILE_PATH');
-            }
-        });
-
-        it('should trim file path before reading', async () => {
-            const filePath = join(tempDir, 'trimmed.txt');
-            await fs.writeFile(filePath, 'Trimmed content');
-
-            const result = await resolveInput({
-                filePath: `  ${filePath}  `,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('Trimmed content');
-            }
-        });
-    });
-
-    describe('stdin input', () => {
-        it('should NOT treat an inherited stdin stream as provided unless explicitly requested', async () => {
-            const mockStdin = createMockStdin('Should be ignored');
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                // stdinRequested intentionally omitted
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBeNull();
-                expect(result.value.source).toBe('none');
-            }
-        });
-
-        it('should read content from stdin', async () => {
-            const mockStdin = createMockStdin('Stdin content');
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('Stdin content');
-                expect(result.value.source).toBe('stdin');
-            }
-        });
-
-        it('should return null for TTY stdin', async () => {
-            const mockStdin = createMockStdin('', true);
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBeNull();
-                expect(result.value.source).toBe('none');
-            }
-        });
-
-        it('should read stdin when stdinRequested is true', async () => {
-            const mockStdin = createMockStdin('Requested stdin');
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('Requested stdin');
-                expect(result.value.source).toBe('stdin');
-            }
-        });
-
-        it('should skip stdin when stdinRequested is false', async () => {
-            const mockStdin = createMockStdin('Ignored stdin');
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: false,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBeNull();
-                expect(result.value.source).toBe('none');
-            }
-        });
-    });
-
-    describe('multiple sources error', () => {
-        it('should error when content and file are both provided', async () => {
-            const result = await resolveInput({
-                content: 'Content',
-                filePath: '/some/file.txt',
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('MULTIPLE_CONTENT_SOURCES');
-            }
-        });
-
-        it('should error when content and stdin are both requested', async () => {
-            const result = await resolveInput({
-                content: 'Content',
-                stream: createMockStdin('Stdin content'),
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('MULTIPLE_CONTENT_SOURCES');
-            }
-        });
-
-        it('should error when file and stdin are both requested', async () => {
-            const result = await resolveInput({
-                filePath: '/some/file.txt',
-                stream: createMockStdin('Stdin content'),
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('MULTIPLE_CONTENT_SOURCES');
-            }
-        });
-
-        it('should error when all three sources are provided', async () => {
-            const result = await resolveInput({
-                content: 'Content',
-                filePath: '/some/file.txt',
-                stream: createMockStdin('Stdin content'),
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('MULTIPLE_CONTENT_SOURCES');
-            }
-        });
-    });
-
-    describe('missing content error', () => {
-        it('should return null content when no source was provided', async () => {
-            const result = await resolveInput({
-                content: undefined,
-                filePath: undefined,
-                stream: undefined,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBeNull();
-                expect(result.value.source).toBe('none');
-            }
-        });
-    });
-
-    describe('priority order', () => {
-        it('should prefer content flag over file', async () => {
-            // This should error because both are provided
-            const result = await resolveInput({
-                content: 'Flag content',
-                filePath: join(tempDir, 'file.txt'),
-            });
-
-            expect(result.ok()).toBe(false);
-            if (!result.ok()) {
-                expect(result.error.code).toBe('MULTIPLE_CONTENT_SOURCES');
-            }
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle multi-chunk stdin', async () => {
-            const mockStdin = Readable.from([
-                'chunk1',
-                'chunk2',
-                'chunk3',
-            ]) as NodeJS.ReadableStream & { isTTY?: boolean };
-            mockStdin.isTTY = false;
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('chunk1chunk2chunk3');
-            }
-        });
-
-        it('should handle stdin without setEncoding', async () => {
-            // Create a minimal stream that doesn't have setEncoding
-            const mockStdin = {
-                isTTY: false,
-                [Symbol.asyncIterator]: async function* () {
-                    yield 'test data';
-                },
-            } as unknown as NodeJS.ReadableStream;
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBe('test data');
-            }
-        });
-
-        it('should handle empty options', async () => {
-            const mockStdin = Readable.from([]) as NodeJS.ReadableStream & { isTTY?: boolean };
-            mockStdin.isTTY = true;
-
-            const result = await resolveInput({
-                stream: mockStdin,
-                stdinRequested: true,
-            });
-
-            expect(result.ok()).toBe(true);
-            if (result.ok()) {
-                expect(result.value.content).toBeNull();
-                expect(result.value.source).toBe('none');
-            }
-        });
-    });
-});

package/src/utils/input.ts

@@ -1,150 +0,0 @@
-/**
- * CLI helpers for resolving memory content input.
- */
-
-import { readFile } from 'node:fs/promises';
-import { err, ok, type Result } from '@yeseh/cortex-core';
-
-export type MemoryContentSource = 'flag' | 'file' | 'stdin' | 'none';
-
-export type InputSource = {
-    content?: string;
-    filePath?: string;
-    /**
-     * stdin stream to read from.
-     *
-     * NOTE: Passing a stream does not necessarily mean stdin is intended as an input
-     * source. Use `stdinRequested: true` when a command semantics include reading from
-     * stdin by default (e.g. `memory add`), typically when piping.
-     */
-    stream?: NodeJS.ReadableStream;
-    /**
-     * Explicitly indicates stdin should be considered as an input source.
-     *
-     * This is `false` by default so that inheriting a non-TTY stdin in test harnesses
-     * or subprocess environments does not accidentally count as providing `--stdin`.
-     */
-    stdinRequested?: boolean;
-};
-
-export interface InputContent {
-    content: string | null;
-    source: MemoryContentSource;
-}
-
-export type InputErrorCode =
-    | 'MULTIPLE_CONTENT_SOURCES'
-    | 'FILE_READ_FAILED'
-    | 'MISSING_CONTENT'
-    | 'INVALID_FILE_PATH';
-
-export interface InputError {
-    code: InputErrorCode;
-    message: string;
-    path?: string;
-    cause?: unknown;
-}
-
-type InputResult = Result<InputContent, InputError>;
-type OptionalContentResult = Result<InputContent | null, InputError>;
-
-export const readContentFromFile = async (
-    filePath: string | undefined,
-): Promise<OptionalContentResult> => {
-    if (filePath === undefined) {
-        return ok(null);
-    }
-    const trimmed = filePath.trim();
-    if (!trimmed) {
-        return err({
-            code: 'INVALID_FILE_PATH',
-            message: 'File path must be a non-empty string.',
-        });
-    }
-    try {
-        const content = await readFile(trimmed, 'utf8');
-        return ok({ content, source: 'file' });
-    }
-    catch (error) {
-        return err({
-            code: 'FILE_READ_FAILED',
-            message: `Failed to read content file: ${trimmed}.`,
-            path: trimmed,
-            cause: error,
-        });
-    }
-};
-
-export const readContentFromStream = async (
-    stream: NodeJS.ReadableStream,
-): Promise<OptionalContentResult> => {
-    const isTty = 'isTTY' in stream ? Boolean(stream.isTTY) : false;
-    if (isTty) {
-        return ok(null);
-    }
-
-    if ('setEncoding' in stream && typeof stream.setEncoding === 'function') {
-        stream.setEncoding('utf8');
-    }
-
-    let data = '';
-    for await (const chunk of stream) {
-        data += String(chunk);
-    }
-
-    return ok({ content: data, source: 'stdin' });
-};
-
-/*
- * Main function to resolve content input from various sources.
- */
-export const resolveInput = async (source: InputSource): Promise<InputResult> => {
-    const contentProvided = source.content !== undefined;
-    const fileProvided = source.filePath !== undefined && source.filePath.trim() !== '';
-
-    // stdin must be explicitly requested by the caller. Merely having a stream
-    // attached (e.g. inherited stdin in a subprocess) should not count as providing
-    // an input source.
-    const streamRequested =
-        source.stdinRequested === true &&
-        source.stream !== null &&
-        source.stream !== undefined &&
-        !('isTTY' in source.stream && Boolean((source.stream as { isTTY?: boolean }).isTTY));
-
-    const requestedSources = [
-        contentProvided,
-        fileProvided,
-        streamRequested,
-    ].filter(Boolean);
-
-    if (requestedSources.length > 1) {
-        return err({
-            code: 'MULTIPLE_CONTENT_SOURCES',
-            message: 'Provide either --content, --file, or --stdin, not multiple sources.',
-        });
-    }
-
-    if (contentProvided) {
-        return ok({ content: source.content ?? '', source: 'flag' });
-    }
-
-    const fileResult = await readContentFromFile(source.filePath);
-    if (!fileResult.ok()) {
-        return fileResult;
-    }
-    if (fileResult.value) {
-        return ok(fileResult.value);
-    }
-
-    if (streamRequested) {
-        const stdinResult = await readContentFromStream(source.stream!);
-        if (!stdinResult.ok()) {
-            return stdinResult;
-        }
-        if (stdinResult.value) {
-            return ok(stdinResult.value);
-        }
-    }
-
-    return ok({ content: null, source: 'none' });
-};