@thegitai/cli 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/src/tools/replace-document-text.js

@@ -0,0 +1,242 @@
+import chalk from '../colors.js';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { isSensitiveProjectPath, normalizeProjectRelativePath, } from '../artifact-policy.js';
+import { readCliAuthConfig } from '../api/auth.js';
+import { resolveProjectPath, writeProjectFileBuffer } from '../patcher.js';
+import { suggestClosestPath } from './path-suggest.js';
+import { isTuiMode } from '../runtime-mode.js';
+function normalizeReplacements(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return null;
+        const entry = item;
+        const oldText = String(entry.oldText ?? entry.old_text ?? '');
+        const newText = String(entry.newText ?? entry.new_text ?? '');
+        if (!oldText)
+            return null;
+        return { oldText, newText };
+    })
+        .filter(Boolean);
+}
+function relativeEditablePath(rootDir, rawPath) {
+    const resolvedPath = path.isAbsolute(rawPath)
+        ? rawPath
+        : path.resolve(rootDir, rawPath);
+    const projectPath = normalizeProjectRelativePath(rootDir, resolvedPath);
+    if (!projectPath || isSensitiveProjectPath(projectPath))
+        return null;
+    return projectPath.split(path.sep).join('/');
+}
+function renderPreview(filePath, preview) {
+    if (isTuiMode())
+        return;
+    console.log(chalk.bold(`\n  Document text replacement preview for ${filePath}:`));
+    for (const line of preview.split('\n')) {
+        if (line.startsWith('+')) {
+            console.log(chalk.green(line));
+        }
+        else if (line.startsWith('-')) {
+            console.log(chalk.red(line));
+        }
+        else if (line.startsWith('@@')) {
+            console.log(chalk.cyan(line));
+        }
+        else {
+            console.log(chalk.dim(line));
+        }
+    }
+    console.log();
+}
+async function replaceDocumentTextOnServer(config, fileName, fileData, replacements, replaceAll, validate) {
+    const response = await globalThis.fetch(`${config.serverUrl.replace(/\/+$/, '')}/v1/document/replace-text`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            fileName,
+            fileData: fileData.toString('base64'),
+            replacements,
+            replaceAll,
+            validate,
+        }),
+    });
+    const data = await response.json().catch(() => null);
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: `Server document edit failed: ${data?.error?.message ?? response.status}`,
+        };
+    }
+    return data;
+}
+export async function replaceDocumentText(context, args) {
+    const sourceRaw = String(args.filePath ?? args.file_path ?? '').trim();
+    if (!sourceRaw) {
+        return { ok: false, error: 'filePath is required' };
+    }
+    const sourcePath = relativeEditablePath(context.rootDir, sourceRaw);
+    if (!sourcePath) {
+        return {
+            ok: false,
+            error: 'replace_document_text can only edit permitted files inside the project root.',
+            failureCategory: 'permission_denied',
+        };
+    }
+    if (path.extname(sourcePath).toLowerCase() !== '.docx') {
+        return {
+            ok: false,
+            error: 'replace_document_text only supports .docx files.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const outputRaw = String(args.outputPath ?? args.output_path ?? '').trim();
+    const targetPath = outputRaw
+        ? relativeEditablePath(context.rootDir, outputRaw)
+        : sourcePath;
+    if (!targetPath) {
+        return {
+            ok: false,
+            error: 'outputPath must be inside the project root.',
+            failureCategory: 'permission_denied',
+        };
+    }
+    if (path.extname(targetPath).toLowerCase() !== '.docx') {
+        return {
+            ok: false,
+            error: 'outputPath must end with .docx.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const replacements = normalizeReplacements(args.replacements);
+    if (!replacements.length) {
+        return {
+            ok: false,
+            error: 'replacements must include at least one { oldText, newText } item.',
+            failureCategory: 'missing_required_argument',
+        };
+    }
+    const authConfig = readCliAuthConfig(context.env);
+    if (!authConfig) {
+        return {
+            ok: false,
+            error: 'Document editing requires a server connection. Please log in first.',
+        };
+    }
+    const sourceAbsPath = resolveProjectPath(context.rootDir, sourcePath);
+    if (!existsSync(sourceAbsPath)) {
+        const suggestion = suggestClosestPath(context.rootDir, sourceAbsPath);
+        return {
+            ok: false,
+            filePath: sourcePath,
+            error: suggestion
+                ? `File does not exist: ${sourcePath}. Did you mean "${suggestion}"? Note the exact punctuation (e.g. curly apostrophe ’ vs straight ').`
+                : `File does not exist: ${sourcePath}`,
+            failureCategory: 'not_found',
+        };
+    }
+    const validateOnly = args.validate === true || args.dryRun === true;
+    const serverResult = await replaceDocumentTextOnServer(authConfig, path.basename(sourcePath), readFileSync(sourceAbsPath), replacements, args.replaceAll === true || args.replace_all === true, validateOnly);
+    if (!serverResult.ok) {
+        return {
+            ...serverResult,
+            filePath: sourcePath,
+            failureCategory: serverResult.failureCategory ?? 'external_service',
+        };
+    }
+    // Validate-only: report per-replacement match info without touching the file.
+    // changed:false marks it non-mutating so the agent loop does not count a
+    // dry-run as an applied edit.
+    if (validateOnly) {
+        return {
+            ok: true,
+            validate: true,
+            changed: false,
+            filePath: sourcePath,
+            operation: 'replace_document_text',
+            results: serverResult.results,
+        };
+    }
+    // No replacement matched: nothing was written. Surface per-item reasons so
+    // the model can correct and resend only the failing entries.
+    const replacementCount = Number(serverResult.replacementCount ?? 0);
+    if (replacementCount === 0) {
+        const failures = Array.isArray(serverResult.replacements)
+            ? serverResult.replacements
+                .filter((item) => item && item.ok === false)
+                .map((item) => `- ${item.error ?? 'no match'}`)
+            : [];
+        return {
+            ok: false,
+            filePath: sourcePath,
+            operation: 'replace_document_text',
+            failureCategory: 'conflict',
+            error: `0 of ${serverResult.requestedCount ?? replacements.length} replacements applied; file unchanged.` +
+                (failures.length ? `\n${failures.join('\n')}` : ''),
+            replacements: serverResult.replacements,
+        };
+    }
+    const preview = String(serverResult.preview ?? '');
+    renderPreview(targetPath, preview);
+    if (!context.autoYes && context.confirmPatch) {
+        const confirmed = await context.confirmPatch(targetPath, preview);
+        if (!confirmed) {
+            if (!isTuiMode()) {
+                console.log(chalk.dim(`  replace_document_text skipped: ${targetPath}`));
+            }
+            return {
+                ok: false,
+                skipped: true,
+                filePath: targetPath,
+                error: 'User declined replace_document_text',
+            };
+        }
+    }
+    const fileData = String(serverResult.fileData ?? '');
+    const nextData = Buffer.from(fileData, 'base64');
+    const write = writeProjectFileBuffer(context.rootDir, targetPath, nextData);
+    const failedCount = Number(serverResult.failedCount ?? 0);
+    const appliedCount = Number(serverResult.appliedCount ?? replacementCount);
+    const requestedCount = Number(serverResult.requestedCount ?? replacements.length);
+    const partialFailures = Array.isArray(serverResult.replacements)
+        ? serverResult.replacements
+            .filter((item) => item && item.ok === false)
+            .map((item) => `- ${item.error ?? 'no match'}`)
+        : [];
+    return {
+        ok: true,
+        filePath: targetPath,
+        sourceFilePath: sourcePath,
+        changed: write.changed,
+        operation: 'replace_document_text',
+        replacementCount: serverResult.replacementCount,
+        requestedCount: serverResult.requestedCount,
+        appliedCount: serverResult.appliedCount,
+        failedCount: serverResult.failedCount,
+        replacements: serverResult.replacements,
+        bytesWritten: nextData.length,
+        // A partial batch still wrote the matched entries (changed:true above), but
+        // the loop must reflect and repair the missed entries — needsRepair forces
+        // that without losing credit for the applied edits.
+        ...(failedCount > 0
+            ? {
+                needsRepair: true,
+                failureCategory: 'conflict',
+                error: `${appliedCount} of ${requestedCount} replacements applied; ` +
+                    `${failedCount} missed and still need to be fixed:\n` +
+                    partialFailures.join('\n'),
+                failureDetails: {
+                    category: 'conflict',
+                    tool: 'replace_document_text',
+                    action: 'Re-issue replace_document_text for the missed entries only, with corrected oldText. ' +
+                        'Copy the exact text from read_document (mind curly vs straight quotes), or pass validate:true to test a match first.',
+                },
+            }
+            : {}),
+    };
+}

package/dist/src/tools/restore-checkpoint.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { createPromptCheckpoint, restoreCheckpointFiles, } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';

package/dist/src/tools/run-command.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
 import { getBlockedCommandReason, runCommand, } from '../executor.js';
 import { syncIndexFromDisk } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';

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

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
 import { execFileSync, spawn } from 'node:child_process';
 import { syncIndexFromDisk } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';

package/dist/src/tools/str-replace.js

@@ -1,10 +1,12 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
+import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
 import { readProjectFile, writeProjectFile } from '../patcher.js';
 import { upsertIndexFile } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, resolveRedactionTokens } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 function countOccurrences(haystack, needle) {
     if (needle.length === 0)
         return 0;
@@ -92,6 +94,17 @@ export async function strReplace(context, args) {
     if (oldString.length === 0) {
         return { ok: false, error: 'old_string is required and must be non-empty' };
     }
+    const ext = path.extname(filePath).toLowerCase();
+    if (DOCUMENT_EXTENSIONS.has(ext)) {
+        return {
+            ok: false,
+            filePath,
+            error: ext === '.docx'
+                ? 'Use replace_document_text for .docx files.'
+                : `Use read_document for ${ext} files; text replacement is not supported.`,
+            failureCategory: 'invalid_argument',
+        };
+    }
     let originalContent;
     try {
         originalContent = readProjectFile(rootDir, filePath);

package/dist/src/tools/undo-edit.js

@@ -1,6 +1,6 @@
-import chalk from 'chalk';
-import { hashContent, readFileEditSnapshot, } from '../edit-journal.js';
-import { deleteProjectFile, writeProjectFile, } from '../patcher.js';
+import chalk from '../colors.js';
+import { hashStoredContent, readFileEditSnapshot, storedContentBuffer, } from '../edit-journal.js';
+import { deleteProjectFile, writeProjectFile, writeProjectFileBuffer, } from '../patcher.js';
 import { removeIndexFile, upsertIndexFile, } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
@@ -84,7 +84,7 @@ function validateUndoPlan(rootDir, records) {
                     currentHash,
                 };
             }
-            const beforeContentHash = hashContent(record.beforeContent);
+            const beforeContentHash = hashStoredContent(record.beforeContent, record.beforeContentEncoding);
             if (beforeContentHash !== record.beforeHash) {
                 return {
                     ok: false,
@@ -110,7 +110,9 @@ async function applyUndo(context, record) {
     if (record.beforeContent === null) {
         throw new Error(`Cannot undo ${record.id}: the stored pre-edit snapshot is incomplete.`);
     }
-    const { changed } = writeProjectFile(rootDir, record.filePath, record.beforeContent);
+    const { changed } = record.beforeContentEncoding === 'base64'
+        ? writeProjectFileBuffer(rootDir, record.filePath, storedContentBuffer(record.beforeContent, record.beforeContentEncoding))
+        : writeProjectFile(rootDir, record.filePath, record.beforeContent);
     if (changed) {
         await upsertIndexFile(projectIndex, record.filePath);
     }

package/dist/src/tools/write-file.js

@@ -1,10 +1,12 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
+import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
 import { writeProjectFile } from '../patcher.js';
 import { upsertIndexFile } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, hasFreshFullReadCoverage, resolveRedactionTokens, } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 export async function writeFile(context, args) {
     const { rootDir, projectIndex } = context;
     const filePath = String(args.filePath ?? '').trim();
@@ -12,6 +14,17 @@ export async function writeFile(context, args) {
     if (!filePath) {
         return { ok: false, error: 'filePath is required' };
     }
+    const ext = path.extname(filePath).toLowerCase();
+    if (DOCUMENT_EXTENSIONS.has(ext)) {
+        return {
+            ok: false,
+            filePath,
+            error: ext === '.docx'
+                ? 'Use replace_document_text for .docx files.'
+                : `Use read_document for ${ext} files; write_file is not supported.`,
+            failureCategory: 'invalid_argument',
+        };
+    }
     const coveragePath = normalizeProjectRelativePath(rootDir, filePath) ?? filePath;
     const currentHash = getCurrentFileHash(rootDir, filePath);
     if (currentHash !== null &&

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

@@ -5,8 +5,21 @@ 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));
+// web-tree-sitter is vendored (see vendor/web-tree-sitter/NOTICE) so the
+// published package has zero runtime dependencies. Resolve the vendored CommonJS
+// runtime relative to this compiled file: dist/src/ -> dist/vendor in the
+// published layout, with the source tree as a dev fallback. The .cjs locates its
+// own web-tree-sitter.wasm next to itself via __dirname, so no locateFile
+// override is needed.
+function resolveVendoredTreeSitter() {
+    const candidates = [
+        path.resolve(__dirname, '..', 'vendor', 'web-tree-sitter', 'web-tree-sitter.cjs'),
+        path.resolve(__dirname, '..', '..', 'vendor', 'web-tree-sitter', 'web-tree-sitter.cjs'),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+const TreeSitter = require(resolveVendoredTreeSitter());
 let parserInitPromise = null;
 const parserCache = Object.create(null);
 const languageCache = Object.create(null);

package/dist/src/ui/repl.js

@@ -11,7 +11,7 @@ import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSes
 import { truncate } from '../utils.js';
 import { writeClipboardText } from '../core/clipboard.js';
 import { openUrl } from '../core/open-url.js';
-import { formatInteractiveHelpText } from '../help-text.js';
+import { formatAboutCard, formatInteractiveHelpText } from '../help-text.js';
 import { expandPastedChunks, } from './paste-collapse.js';
 import { loadPromptHistory, MAX_PROMPT_HISTORY_ENTRIES, } from './prompt-history-store.js';
 const RESPONSE_STREAM_CHUNK_SIZE = 4;
@@ -86,6 +86,10 @@ export const SLASH_COMMANDS = [
         command: '/help',
         description: 'Show available chat commands',
     },
+    {
+        command: '/about',
+        description: 'Show version and platform info',
+    },
     {
         command: '/usage',
         description: 'Show account usage percentage and reset times',
@@ -1875,6 +1879,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 });
                 return;
             }
+            if (input === '/about') {
+                appendStaticEntry({
+                    body: formatAboutCard(),
+                    kind: 'system',
+                    title: 'About',
+                });
+                return;
+            }
             if (input === '/usage') {
                 store.update((current) => ({
                     ...current,

package/dist/src/ui/tui/bridge.js

@@ -114,13 +114,13 @@ export function resolveTuiBinaryPath() {
 export function spawnTuiProcess(options = {}) {
     const binaryPath = resolveTuiBinaryPath();
     return spawn(binaryPath, [], {
-        stdio: ['pipe', 'pipe', 'inherit'],
+        stdio: ['pipe', 'inherit', 'pipe'],
         env: { ...process.env, ...options.env },
     });
 }
 export function createRatatuiBridge() {
     const child = spawnTuiProcess();
-    const rl = createInterface({ input: child.stdout });
+    const rl = createInterface({ input: child.stderr });
     let eventHandler = null;
     let closed = false;
     rl.on('line', (line) => {

package/dist/src/ui/tui/build-frame.js

@@ -131,6 +131,18 @@ function diffLinePrefix(kind) {
             return ' ';
     }
 }
+// Fit a single diff line to the available terminal width with a clean ellipsis.
+// Unlike the general-purpose truncate(), this never appends a word like
+// "(truncated)" — that wording belongs on tool output, not on-screen diff rows.
+function fitDiffLine(content, maxWidth) {
+    if (maxWidth <= 0)
+        return '';
+    if (content.length <= maxWidth)
+        return content;
+    if (maxWidth === 1)
+        return '…';
+    return `${content.slice(0, maxWidth - 1)}…`;
+}
 export function formatPromptDirectoryLabel(projectRoot, homeDir = process.env.HOME ?? '') {
     const trimmed = String(projectRoot ?? '').trim();
     if (!trimmed)
@@ -228,7 +240,7 @@ export function renderTranscriptEntryLines(entry, width) {
     if (entry.diffPreview) {
         lines.push(plainLine(`  Added ${entry.diffPreview.added} line${entry.diffPreview.added === 1 ? '' : 's'}, removed ${entry.diffPreview.removed} line${entry.diffPreview.removed === 1 ? '' : 's'}`, { color: 'gray' }));
         for (const diffLine of entry.diffPreview.lines.slice(0, TRANSCRIPT_DIFF_PREVIEW_LINES)) {
-            lines.push(line(span(`${diffLinePrefix(diffLine.kind)} `, { color: diffLineColor(diffLine.kind) }), span(truncate(diffLine.content || ' ', width - 4), {
+            lines.push(line(span(`${diffLinePrefix(diffLine.kind)} `, { color: diffLineColor(diffLine.kind) }), span(fitDiffLine(diffLine.content || ' ', width - 4), {
                 color: diffLineColor(diffLine.kind),
             })));
         }
@@ -311,7 +323,11 @@ function composerFooterLines(state) {
         ? state.queuedMessage
             ? 'Enter re-queues • ↑ edit queued • Esc cancels queued'
             : 'Enter queues • Esc / Ctrl+C cancel turn'
-        : 'Enter sends • Shift+Tab mode • Esc cancel turn • Ctrl+C quits';
+        : process.platform === 'win32'
+            ? 'Enter sends • Shift+Tab mode • Alt+V image • Esc cancel turn • Ctrl+C quits'
+            : process.platform === 'darwin'
+                ? 'Enter sends • Shift+Tab mode • Ctrl+V image • Esc cancel turn • Ctrl+C quits'
+                : 'Enter sends • Shift+Tab mode • Ctrl+V image • Esc cancel turn • Ctrl+C quits';
     const agentLabel = agentModeLabel(state.agentMode).padEnd(AGENT_MODE_LABEL_WIDTH);
     const tokenUsageText = state.tokenUsage || formatClientTokenUsage(null);
     const footerSpans = [

package/dist/src/ui/tui/shell-input.js

@@ -1,6 +1,14 @@
 import { readClipboardImage, readClipboardText } from '../../core/clipboard.js';
 import { applySlashCommandSuggestion, buildModelPickerOptions, deleteAtCursor, deleteBeforeCursor, getApprovalChoiceForCursor, getInputCommandToken, getNextApprovalCursor, getNextModelPickerIndex, getSlashCommandSuggestions, insertAtCursor, isExactSlashCommandToken, navigatePromptHistory, resolveApprovalChoiceFromInput, shouldRemountLiveFrameForComposerInputChange, } from '../repl.js';
 import { buildPastePlaceholder, shouldCollapsePaste, } from '../paste-collapse.js';
+function isClipboardImagePasteKey(key) {
+    if (process.platform === 'win32') {
+        return ((key.ctrl || key.meta) &&
+            key.input.toLowerCase() === 'v' &&
+            !key.shift);
+    }
+    return key.ctrl && key.input === 'v' && !key.shift && !key.meta;
+}
 function shouldShowCommandPalette(state) {
     if (state.busy ||
         state.exiting ||
@@ -428,7 +436,7 @@ export function handleShellKeyEvent(store, handlers, event) {
         });
         return;
     }
-    if (key.ctrl && key.input === 'v') {
+    if (isClipboardImagePasteKey(key)) {
         const current = store.getState();
         if (current.busy)
             return;

package/dist/src/version.js

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PACKAGE_NAME = '@thegitai/cli';
+const UNKNOWN_VERSION = '0.0.0';
+// Resolve the package version at runtime by walking up from this module to the
+// nearest package.json named @thegitai/cli. This works in both layouts: the
+// compiled binary (dist/bin/ai.js → ../../package.json) and the source tree run
+// under tsx in tests (src/version.ts → ../package.json). The name guard avoids
+// picking up an unrelated manifest if the file is ever nested elsewhere.
+export function getCliVersion() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 6; depth++) {
+        try {
+            const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+            if (pkg.name === PACKAGE_NAME && typeof pkg.version === 'string') {
+                return pkg.version;
+            }
+        }
+        catch {
+            // No package.json at this level (or unreadable); keep walking up.
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return UNKNOWN_VERSION;
+}
+export function getPlatformTag() {
+    return `${process.platform}-${process.arch}`;
+}
+export function formatVersionLine() {
+    return `ai ${getCliVersion()} (${getPlatformTag()}, node ${process.version})`;
+}

package/dist/vendor/web-tree-sitter/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/vendor/web-tree-sitter/NOTICE

@@ -0,0 +1,13 @@
+web-tree-sitter
+===============
+
+The files `web-tree-sitter.cjs` and `web-tree-sitter.wasm` in this directory are
+vendored, unmodified, from the `web-tree-sitter` npm package, version 0.26.6.
+
+They are bundled here (rather than installed as a runtime dependency) so the
+published `@thegitai/cli` package declares zero runtime dependencies while still
+shipping local tree-sitter code intelligence. They are used only as a local
+parsing runtime; no part of web-tree-sitter is modified.
+
+Upstream: https://github.com/tree-sitter/tree-sitter
+License:  MIT (see the adjacent LICENSE file)