@thegitai/cli 1.0.0-preview.3 → 1.0.0-preview.30

package/dist/src/markdown-renderer.js

@@ -1,112 +0,0 @@
-import chalk from './colors.js';
-function renderInline(text) {
-    const parts = String(text ?? '').split(/(`[^`]+`)/g);
-    return parts
-        .map((part) => part.startsWith('`') && part.endsWith('`') && part.length > 1
-        ? chalk.cyan(part.slice(1, -1))
-        : part)
-        .join('');
-}
-function isTableSeparator(line) {
-    const cells = splitTableRow(line);
-    return (cells.length > 1 &&
-        cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim())));
-}
-function splitTableRow(line) {
-    const trimmed = String(line ?? '').trim();
-    if (!trimmed.includes('|'))
-        return [];
-    return trimmed
-        .replace(/^\|/, '')
-        .replace(/\|$/, '')
-        .split('|')
-        .map((cell) => cell.trim());
-}
-function tableWidth(text) {
-    return text.replace(/\x1b\[[0-9;]*m/g, '').length;
-}
-function padCell(text, width) {
-    return `${text}${' '.repeat(Math.max(0, width - tableWidth(text)))}`;
-}
-function renderTable(rows) {
-    if (rows.length < 2 || !isTableSeparator(rows[1].join('|')))
-        return [];
-    const headers = rows[0];
-    const body = rows.slice(2).filter((row) => row.length > 0);
-    const columnCount = Math.max(headers.length, ...body.map((row) => row.length));
-    const normalizedRows = [headers, ...body].map((row) => Array.from({ length: columnCount }, (_, index) => renderInline(row[index] ?? '')));
-    const widths = Array.from({ length: columnCount }, (_, index) => Math.max(...normalizedRows.map((row) => tableWidth(row[index] ?? '')), 3));
-    const border = `+${widths.map((width) => '-'.repeat(width + 2)).join('+')}+`;
-    const renderRow = (row) => `| ${row.map((cell, index) => padCell(cell, widths[index])).join(' | ')} |`;
-    return [
-        border,
-        renderRow(normalizedRows[0].map((cell) => chalk.bold(cell))),
-        border,
-        ...normalizedRows.slice(1).map(renderRow),
-        border,
-    ];
-}
-function readTableBlock(lines, startIndex) {
-    if (startIndex + 1 >= lines.length)
-        return null;
-    const header = splitTableRow(lines[startIndex]);
-    const separator = splitTableRow(lines[startIndex + 1]);
-    if (header.length < 2 || separator.length < 2 || !isTableSeparator(lines[startIndex + 1])) {
-        return null;
-    }
-    const rows = [header, separator];
-    let index = startIndex + 2;
-    while (index < lines.length) {
-        const row = splitTableRow(lines[index]);
-        if (row.length < 2)
-            break;
-        rows.push(row);
-        index += 1;
-    }
-    const rendered = renderTable(rows);
-    return rendered.length ? { rendered, nextIndex: index } : null;
-}
-export function renderMarkdownForTerminal(markdown) {
-    const lines = String(markdown ?? '').replace(/\r\n?/g, '\n').split('\n');
-    const output = [];
-    let inCodeBlock = false;
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        if (/^\s*```/.test(line)) {
-            inCodeBlock = !inCodeBlock;
-            continue;
-        }
-        if (inCodeBlock) {
-            output.push(chalk.dim(`  ${line}`));
-            continue;
-        }
-        const table = readTableBlock(lines, index);
-        if (table) {
-            output.push(...table.rendered);
-            index = table.nextIndex - 1;
-            continue;
-        }
-        const heading = line.match(/^\s{0,3}#{1,6}\s+(.+)$/);
-        if (heading) {
-            output.push(chalk.bold(renderInline(heading[1].trim())));
-            continue;
-        }
-        const bullet = line.match(/^(\s*)[-*]\s+(.+)$/);
-        if (bullet) {
-            output.push(`${bullet[1]}- ${renderInline(bullet[2].trim())}`);
-            continue;
-        }
-        const numbered = line.match(/^(\s*)\d+[.)]\s+(.+)$/);
-        if (numbered) {
-            output.push(`${numbered[1]}- ${renderInline(numbered[2].trim())}`);
-            continue;
-        }
-        const quote = line.match(/^\s*>\s?(.+)$/);
-        if (quote) {
-            output.push(chalk.dim(`> ${renderInline(quote[1].trim())}`));
-            continue;
-        }
-        output.push(renderInline(line));
-    }
-    return output.join('\n').trimEnd();
-}

package/dist/src/project-index.js

@@ -1,221 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { listProjectFiles, scanFiles, shouldIgnorePath, } from './scanner.js';
-import { truncate } from './utils.js';
-function normalizeProjectFilePath(rootDir, filePath) {
-    const resolvedRoot = path.resolve(rootDir);
-    const resolvedFile = path.resolve(resolvedRoot, filePath);
-    const relative = path.relative(resolvedRoot, resolvedFile);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        return null;
-    }
-    return relative.replace(/\\/g, '/');
-}
-function getFileSignature(rootDir, relPath) {
-    try {
-        const stat = statSync(path.join(rootDir, relPath));
-        if (!stat.isFile()) {
-            return null;
-        }
-        return `${stat.size}:${stat.mtimeMs}`;
-    }
-    catch {
-        return null;
-    }
-}
-function setChunksForFile(index, relPath, chunks) {
-    if (chunks.length === 0) {
-        index.chunksByFile.delete(relPath);
-        index.fileSignatures.delete(relPath);
-        return;
-    }
-    index.chunksByFile.set(relPath, chunks);
-    const signature = getFileSignature(index.rootDir, relPath);
-    if (signature) {
-        index.fileSignatures.set(relPath, signature);
-    }
-}
-function removeFile(index, relPath) {
-    index.chunksByFile.delete(relPath);
-    index.fileSignatures.delete(relPath);
-}
-async function initializeIndex(index) {
-    if (index.initialized) {
-        return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
-    }
-    const files = listProjectFiles(index.rootDir);
-    const chunks = await scanFiles(index.rootDir, files);
-    index.fileSignatures.clear();
-    index.chunksByFile.clear();
-    for (const filePath of files) {
-        const signature = getFileSignature(index.rootDir, filePath);
-        if (signature) {
-            index.fileSignatures.set(filePath, signature);
-        }
-    }
-    for (const chunk of chunks) {
-        const current = index.chunksByFile.get(chunk.filePath) ?? [];
-        current.push(chunk);
-        index.chunksByFile.set(chunk.filePath, current);
-    }
-    index.initialized = true;
-    index.onStatus?.(`Local code index ready: ${index.fileSignatures.size.toLocaleString()} files.`);
-    return chunks.length;
-}
-function queryTerms(query) {
-    const parts = query
-        .toLowerCase()
-        .split(/[^a-z0-9_./-]+/i)
-        .map((part) => part.trim())
-        .filter(Boolean);
-    return [...new Set(parts)];
-}
-function countOccurrences(haystack, needle) {
-    if (!needle)
-        return 0;
-    let count = 0;
-    let cursor = 0;
-    while (cursor < haystack.length) {
-        const index = haystack.indexOf(needle, cursor);
-        if (index === -1)
-            break;
-        count += 1;
-        cursor = index + needle.length;
-    }
-    return count;
-}
-function scoreChunk(terms, chunk) {
-    const filePath = chunk.filePath.toLowerCase();
-    const content = chunk.content.toLowerCase();
-    let score = 0;
-    for (const term of terms) {
-        if (term.length < 2)
-            continue;
-        score += countOccurrences(filePath, term) * 3;
-        score += countOccurrences(content, term);
-        if (chunk.label?.toLowerCase().includes(term)) {
-            score += 2;
-        }
-    }
-    return score;
-}
-function flattenChunks(index) {
-    return Array.from(index.chunksByFile.values()).flat();
-}
-export function createIndex({ rootDir, onStatus = null, onContextLog = null, }) {
-    return {
-        rootDir: path.resolve(rootDir),
-        initialized: false,
-        fileSignatures: new Map(),
-        chunksByFile: new Map(),
-        onStatus,
-        onContextLog,
-    };
-}
-export async function searchIndex(index, query, limit = 10) {
-    await initializeIndex(index);
-    const terms = queryTerms(query);
-    if (terms.length === 0) {
-        return { results: [], retrievalTokensUsed: 0 };
-    }
-    const scored = flattenChunks(index)
-        .map((chunk) => ({
-        ...chunk,
-        score: scoreChunk(terms, chunk),
-    }))
-        .filter((chunk) => chunk.score > 0)
-        .sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath))
-        .slice(0, Math.max(1, Math.min(limit, 20)));
-    if (scored.length) {
-        const visible = scored
-            .slice(0, 6)
-            .map((chunk) => `${chunk.filePath}:${chunk.startLine}-${chunk.endLine}`)
-            .join(', ');
-        index.onContextLog?.(`Local search hit: ${visible}`);
-    }
-    return {
-        results: scored,
-        retrievalTokensUsed: 0,
-    };
-}
-export function formatIndexResults(results) {
-    return results.map((chunk) => ({
-        ...chunk,
-        content: truncate(chunk.content, 1200),
-    }));
-}
-export function listIndexFiles(index) {
-    return [...index.fileSignatures.keys()].sort();
-}
-export async function upsertIndexFile(index, filePath) {
-    if (!index.initialized) {
-        return { indexedChunks: 0, retrievalTokensUsed: 0 };
-    }
-    const relPath = normalizeProjectFilePath(index.rootDir, filePath);
-    if (!relPath || shouldIgnorePath(relPath)) {
-        return { indexedChunks: 0, retrievalTokensUsed: 0 };
-    }
-    const chunks = existsSync(path.join(index.rootDir, relPath))
-        ? await scanFiles(index.rootDir, [relPath])
-        : [];
-    setChunksForFile(index, relPath, chunks);
-    return {
-        indexedChunks: chunks.length,
-        retrievalTokensUsed: 0,
-    };
-}
-export async function removeIndexFile(index, filePath) {
-    const relPath = normalizeProjectFilePath(index.rootDir, filePath);
-    if (!relPath)
-        return;
-    removeFile(index, relPath);
-}
-export async function syncIndexFromDisk(index) {
-    if (!index.initialized) {
-        const indexedChunks = await initializeIndex(index);
-        return {
-            added: index.fileSignatures.size,
-            modified: 0,
-            removed: 0,
-            indexedChunks,
-            retrievalTokensUsed: 0,
-        };
-    }
-    const currentFiles = new Set(listProjectFiles(index.rootDir));
-    let added = 0;
-    let modified = 0;
-    let removed = 0;
-    let indexedChunks = 0;
-    for (const existing of [...index.fileSignatures.keys()]) {
-        if (!currentFiles.has(existing)) {
-            removeFile(index, existing);
-            removed += 1;
-        }
-    }
-    for (const relPath of currentFiles) {
-        const nextSignature = getFileSignature(index.rootDir, relPath);
-        if (!nextSignature)
-            continue;
-        const previousSignature = index.fileSignatures.get(relPath);
-        if (!previousSignature) {
-            const chunks = await scanFiles(index.rootDir, [relPath]);
-            setChunksForFile(index, relPath, chunks);
-            added += 1;
-            indexedChunks += chunks.length;
-            continue;
-        }
-        if (previousSignature !== nextSignature) {
-            const chunks = await scanFiles(index.rootDir, [relPath]);
-            setChunksForFile(index, relPath, chunks);
-            modified += 1;
-            indexedChunks += chunks.length;
-        }
-    }
-    return {
-        added,
-        modified,
-        removed,
-        indexedChunks,
-        retrievalTokensUsed: 0,
-    };
-}