@thegitai/cli 1.0.0-beta.1

package/dist/src/tools/run-node-script.js

@@ -0,0 +1,210 @@
+import chalk from 'chalk';
+import { execFileSync, spawn } from 'node:child_process';
+import { syncIndexFromDisk } from '../project-index.js';
+import { isTuiMode } from '../runtime-mode.js';
+import { buildDeferredShellDiagnostics, invalidateShellDiagnosticsCache, } from './shell-diagnostics.js';
+const DEFAULT_TIMEOUT = 5 * 60 * 1000;
+const MAX_OUTPUT_CHARS = 4000;
+const MAX_CAPTURE_CHARS = 1024 * 1024;
+const COMMAND_LABEL = 'node --input-type=module <script via stdin>';
+const MAX_APPROVAL_SCRIPT_CHARS = 4000;
+function describeNodeScriptForApproval(script) {
+    if (script.length <= MAX_APPROVAL_SCRIPT_CHARS) {
+        return `${COMMAND_LABEL}\n${script}`;
+    }
+    return `${COMMAND_LABEL}\n${script.slice(0, MAX_APPROVAL_SCRIPT_CHARS)}\n... (${script.length - MAX_APPROVAL_SCRIPT_CHARS} more characters truncated)`;
+}
+function appendCapturedText(current, chunk) {
+    if (!chunk || current.length >= MAX_CAPTURE_CHARS)
+        return current;
+    return current + chunk.slice(0, MAX_CAPTURE_CHARS - current.length);
+}
+function trimOutput(text) {
+    if (!text)
+        return '';
+    if (text.length <= MAX_OUTPUT_CHARS)
+        return text;
+    const headSize = Math.floor(MAX_OUTPUT_CHARS * 0.2);
+    const tailSize = MAX_OUTPUT_CHARS - headSize;
+    return (text.slice(0, headSize) +
+        `\n\n... (${text.length - headSize - tailSize} chars truncated) ...\n\n` +
+        text.slice(-tailSize));
+}
+function terminateChild(child, signal) {
+    if (!child?.pid)
+        return;
+    if (process.platform === 'win32') {
+        try {
+            child.kill(signal);
+        }
+        catch { }
+        return;
+    }
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        try {
+            child.kill(signal);
+        }
+        catch { }
+    }
+}
+function buildOutput(stdout, stderr, exitCode) {
+    if (exitCode === 0)
+        return trimOutput(stdout.trim());
+    return trimOutput([stdout, stderr].filter(Boolean).join('\n').trim());
+}
+function emptyRepoSync(reason) {
+    return {
+        added: 0,
+        modified: 0,
+        removed: 0,
+        indexedChunks: 0,
+        retrievalTokensUsed: 0,
+        skipped: true,
+        ...(reason ? { reason } : {}),
+    };
+}
+function readGitStatusSignature(rootDir) {
+    try {
+        return execFileSync('git', ['-C', rootDir, 'status', '--porcelain=v1', '--untracked-files=all'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10_000,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function executeNodeScript(rootDir, script, timeout) {
+    const effectiveTimeout = typeof timeout === 'number' && timeout > 0
+        ? timeout
+        : DEFAULT_TIMEOUT;
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        let timeoutTimer = null;
+        let killTimer = null;
+        const child = spawn(process.execPath, ['--input-type=module'], {
+            cwd: rootDir,
+            detached: process.platform !== 'win32',
+            env: {
+                ...process.env,
+                CI: 'true',
+                npm_config_yes: 'true',
+                npm_config_progress: 'false',
+                npm_config_fund: 'false',
+                npm_config_audit: 'false',
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const finish = (exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({
+                exitCode,
+                stdout,
+                stderr,
+                output: buildOutput(stdout, stderr, exitCode),
+                timedOut,
+            });
+        };
+        timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            terminateChild(child, 'SIGTERM');
+            killTimer = setTimeout(() => terminateChild(child, 'SIGKILL'), 2000);
+            killTimer.unref?.();
+        }, effectiveTimeout);
+        timeoutTimer.unref?.();
+        child.stdout?.on('data', (chunk) => {
+            const text = chunk.toString('utf-8');
+            stdout = appendCapturedText(stdout, text);
+        });
+        child.stderr?.on('data', (chunk) => {
+            const text = chunk.toString('utf-8');
+            stderr = appendCapturedText(stderr, text);
+        });
+        child.on('error', (error) => {
+            stderr = appendCapturedText(stderr, error.message ? `${error.message}\n` : '');
+            finish(1);
+        });
+        child.on('close', (code, signal) => {
+            finish(timedOut || signal === 'SIGTERM' || signal === 'SIGKILL'
+                ? 1
+                : code ?? 1);
+        });
+        child.stdin?.end(script);
+    });
+}
+export async function runNodeScript(context, args) {
+    const { rootDir, autoYes, confirmCommand } = context;
+    const script = typeof args.script === 'string' ? args.script : '';
+    if (!script.trim()) {
+        return { ok: false, error: 'script is required' };
+    }
+    const commandForApproval = describeNodeScriptForApproval(script);
+    if (!isTuiMode()) {
+        console.log(chalk.bold.yellow(`\n  ⚡ Node script:\n${commandForApproval}\n`));
+        console.log(chalk.dim(`    in: ${rootDir}\n`));
+    }
+    if (!autoYes) {
+        if (confirmCommand == null) {
+            return {
+                ok: false,
+                command: COMMAND_LABEL,
+                error: 'confirmCommand is required when autoYes is false',
+            };
+        }
+        const approved = await confirmCommand(commandForApproval);
+        if (!approved) {
+            if (!isTuiMode()) {
+                console.log(chalk.dim(`  ⏭  Skipped: ${COMMAND_LABEL}`));
+            }
+            return {
+                ok: false,
+                skipped: true,
+                command: COMMAND_LABEL,
+                error: 'User declined command execution',
+            };
+        }
+    }
+    const beforeGitStatus = readGitStatusSignature(rootDir);
+    const result = await executeNodeScript(rootDir, script, typeof args.timeout_ms === 'number' && args.timeout_ms > 0
+        ? args.timeout_ms
+        : undefined);
+    const afterGitStatus = readGitStatusSignature(rootDir);
+    const gitStatusCleanBeforeAndAfter = beforeGitStatus === '' && afterGitStatus === '';
+    const shouldSync = context.projectIndex.initialized && !gitStatusCleanBeforeAndAfter;
+    const repoSync = shouldSync
+        ? await syncIndexFromDisk(context.projectIndex)
+        : emptyRepoSync(!context.projectIndex.initialized
+            ? 'project index not initialized'
+            : gitStatusCleanBeforeAndAfter
+                ? 'git status clean before and after'
+                : 'sync not needed');
+    invalidateShellDiagnosticsCache(rootDir);
+    if (repoSync.added || repoSync.modified || repoSync.removed) {
+        context.onStatus(`Synced repo state after Node script (${repoSync.added} added, ${repoSync.modified} modified, ${repoSync.removed} removed).`);
+    }
+    return {
+        ok: result.exitCode === 0,
+        command: COMMAND_LABEL,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        output: result.output,
+        repoSync,
+        retrievalTokensUsed: repoSync.retrievalTokensUsed,
+        diagnostics: buildDeferredShellDiagnostics('run_node_script'),
+    };
+}

package/dist/src/tools/search-code.js

@@ -0,0 +1,37 @@
+import { formatIndexResults, searchIndex, } from '../project-index.js';
+import { clampInteger } from '../utils.js';
+export async function searchCode(projectIndex, args) {
+    const query = String(args.query ?? '').trim();
+    if (!query) {
+        return { ok: false, error: 'query is required' };
+    }
+    const limit = clampInteger(args.limit, 5, 20);
+    let searchResult;
+    try {
+        searchResult = await searchIndex(projectIndex, query, limit);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/semantic index/i.test(message)) {
+            return {
+                ok: false,
+                skipped: true,
+                failureCategory: 'tool_exception',
+                failureDetails: {
+                    category: 'tool_exception',
+                    tool: 'search_code',
+                    action: 'Search is temporarily unavailable.',
+                },
+                error: 'Search is temporarily unavailable.',
+            };
+        }
+        throw error;
+    }
+    const { results, retrievalTokensUsed } = searchResult;
+    return {
+        ok: true,
+        query,
+        results: formatIndexResults(results),
+        retrievalTokensUsed,
+    };
+}