@thegitai/cli 1.0.0-beta.1

package/dist/src/tree-sitter-runtime.js

@@ -0,0 +1,135 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { addSignatureForNode } from './extractors/index.js';
+import { getRepoMapLanguageForFile, } from './repo-map-languages.js';
+const require = createRequire(import.meta.url);
+const TreeSitter = require('web-tree-sitter');
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+let parserInitPromise = null;
+const parserCache = Object.create(null);
+const languageCache = Object.create(null);
+function getWasmPath(wasmFile) {
+    const candidates = [
+        path.resolve(__dirname, '..', 'parsers', wasmFile),
+        path.resolve(__dirname, '..', '..', 'parsers', wasmFile),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+async function initParserRuntime() {
+    if (!parserInitPromise) {
+        const ts = TreeSitter;
+        const initFn = ts.init ||
+            ts.default?.init ||
+            ts.Parser?.init ||
+            ts.default?.Parser?.init;
+        parserInitPromise =
+            typeof initFn === 'function' ? initFn() : Promise.resolve();
+    }
+    await parserInitPromise;
+}
+function createParser() {
+    const ParserClass = TreeSitter.Parser || TreeSitter.default?.Parser || TreeSitter.default;
+    if (typeof ParserClass !== 'function') {
+        return null;
+    }
+    try {
+        return Reflect.construct(ParserClass, []);
+    }
+    catch {
+        return null;
+    }
+}
+async function getParserForLanguage(languageConfig) {
+    if (parserCache[languageConfig.id]) {
+        return parserCache[languageConfig.id];
+    }
+    try {
+        await initParserRuntime();
+        const wasmPath = getWasmPath(languageConfig.wasmFile);
+        if (!existsSync(wasmPath)) {
+            return null;
+        }
+        let language = languageCache[languageConfig.id];
+        if (!language) {
+            const ts = TreeSitter;
+            const LanguageClass = ts.Language || ts.default?.Language;
+            if (!LanguageClass?.load) {
+                return null;
+            }
+            language = await LanguageClass.load(wasmPath);
+            languageCache[languageConfig.id] = language;
+        }
+        const parser = createParser();
+        if (!parser) {
+            return null;
+        }
+        parser.setLanguage(language);
+        parserCache[languageConfig.id] = parser;
+        return parser;
+    }
+    catch {
+        return null;
+    }
+}
+export async function parseRepoSource(relPath, code) {
+    const languageConfig = getRepoMapLanguageForFile(relPath, path);
+    if (!languageConfig) {
+        return null;
+    }
+    const parser = await getParserForLanguage(languageConfig);
+    if (!parser) {
+        return null;
+    }
+    try {
+        const tree = parser.parse(code);
+        if (!tree) {
+            return null;
+        }
+        return {
+            code,
+            languageConfig,
+            languageId: languageConfig.id,
+            tree,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function collectNodeSignatures(node, languageId, limit = Number.POSITIVE_INFINITY) {
+    const signatures = [];
+    function visit(current) {
+        if (!current || signatures.length >= limit)
+            return;
+        addSignatureForNode(current, languageId, signatures);
+        if (signatures.length >= limit)
+            return;
+        for (let i = 0; i < current.namedChildCount; i++) {
+            visit(current.namedChild(i));
+            if (signatures.length >= limit)
+                return;
+        }
+    }
+    visit(node);
+    return signatures;
+}
+export function getNodePrimarySignature(node, languageId) {
+    return collectNodeSignatures(node, languageId, 1)[0] ?? null;
+}
+export function getStructuralChildren(node) {
+    const body = node?.childForFieldName?.('body');
+    const source = body && body.namedChildCount > 0 ? body : node;
+    const children = [];
+    if (!source) {
+        return children;
+    }
+    for (let i = 0; i < source.namedChildCount; i++) {
+        const child = source.namedChild(i);
+        if (child && child.startIndex < child.endIndex) {
+            children.push(child);
+        }
+    }
+    return children;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/ui/paste-collapse.js

@@ -0,0 +1,22 @@
+const PASTE_LINE_THRESHOLD = 5;
+const PASTE_CHAR_THRESHOLD = 200;
+export function shouldCollapsePaste(text) {
+    return (text.split('\n').length > PASTE_LINE_THRESHOLD ||
+        text.length > PASTE_CHAR_THRESHOLD);
+}
+export function buildPastePlaceholder(text, id) {
+    const lineCount = text.split('\n').length;
+    const label = lineCount > PASTE_LINE_THRESHOLD
+        ? `${lineCount} lines`
+        : `${text.length} chars`;
+    return id === 1
+        ? `[Pasted Text: ${label}]`
+        : `[Pasted Text: ${label} #${id}]`;
+}
+export function expandPastedChunks(input, chunks) {
+    let result = input;
+    for (const chunk of chunks) {
+        result = result.replace(chunk.placeholder, () => chunk.text);
+    }
+    return result;
+}

package/dist/src/ui/prompt-history-store.js

@@ -0,0 +1,96 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { getClientStateDir } from '../client-state.js';
+const HISTORY_FILE = 'prompt-history.json';
+const LEGACY_HISTORY_FILE = 'prompt-history.txt';
+export const MAX_PROMPT_HISTORY_ENTRIES = 15;
+const ENTRY_SEPARATOR = '\x1e';
+function getHistoryFilePath(env = process.env) {
+    return path.join(getClientStateDir(env), HISTORY_FILE);
+}
+function getLegacyHistoryFilePath(env = process.env) {
+    return path.join(getClientStateDir(env), LEGACY_HISTORY_FILE);
+}
+function sanitizeEntry(value) {
+    return value.replace(new RegExp(ENTRY_SEPARATOR, 'g'), '').trim();
+}
+function normalizePromptHistoryEntries(entries) {
+    const uniqueLatest = new Map();
+    for (const entry of entries) {
+        const sanitized = sanitizeEntry(entry);
+        if (!sanitized || sanitized.startsWith('/'))
+            continue;
+        uniqueLatest.delete(sanitized);
+        uniqueLatest.set(sanitized, sanitized);
+    }
+    const normalized = [...uniqueLatest.values()];
+    return normalized.slice(Math.max(0, normalized.length - MAX_PROMPT_HISTORY_ENTRIES));
+}
+function parseJsonPromptHistory(content) {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed))
+        return parsed.map((entry) => String(entry));
+    if (!parsed || typeof parsed !== 'object')
+        return [];
+    const prompts = parsed.prompts;
+    return Array.isArray(prompts) ? prompts.map((entry) => String(entry)) : [];
+}
+function parseLegacyPromptHistory(content) {
+    return content.replace(new RegExp(ENTRY_SEPARATOR, 'g'), '\n').split(/\r?\n/);
+}
+function serializePromptHistory(entries) {
+    return `${JSON.stringify({ version: 1, prompts: entries }, null, 2)}\n`;
+}
+function writePromptHistoryFile(filePath, entries) {
+    writeFileSync(filePath, serializePromptHistory(entries), {
+        encoding: 'utf8',
+        mode: existsSync(filePath) ? undefined : 0o600,
+    });
+}
+export function loadPromptHistory(env = process.env) {
+    const filePath = getHistoryFilePath(env);
+    if (existsSync(filePath)) {
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            if (!content)
+                return [];
+            return normalizePromptHistoryEntries(parseJsonPromptHistory(content));
+        }
+        catch {
+            return [];
+        }
+    }
+    const legacyFilePath = getLegacyHistoryFilePath(env);
+    if (!existsSync(legacyFilePath))
+        return [];
+    try {
+        const content = readFileSync(legacyFilePath, 'utf8');
+        if (!content)
+            return [];
+        const entries = normalizePromptHistoryEntries(parseLegacyPromptHistory(content));
+        mkdirSync(getClientStateDir(env), { recursive: true });
+        writePromptHistoryFile(filePath, entries);
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+export function appendPromptToFile(prompt, env = process.env) {
+    const sanitized = sanitizeEntry(String(prompt ?? ''));
+    if (!sanitized || sanitized.startsWith('/'))
+        return;
+    try {
+        const dir = getClientStateDir(env);
+        mkdirSync(dir, { recursive: true });
+        const filePath = getHistoryFilePath(env);
+        const entries = normalizePromptHistoryEntries([
+            ...loadPromptHistory(env),
+            sanitized,
+        ]);
+        writePromptHistoryFile(filePath, entries);
+    }
+    catch {
+        return;
+    }
+}