@thegitai/cli 1.0.0-beta.1

package/dist/src/extractors/cpp.js

@@ -0,0 +1,18 @@
+import { findNamedChild, getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addCppFamilySignature(node, signatures) {
+    switch (node.type) {
+        case 'class_specifier':
+        case 'struct_specifier':
+        case 'enum_specifier':
+            pushSignature(signatures, `${node.type.split('_')[0]} ${getIdentifierLikeText(node)}`);
+            return;
+        case 'function_definition':
+        case 'declaration': {
+            const funcDeclarator = findNamedChild(node, new Set(['function_declarator']));
+            if (funcDeclarator) {
+                pushSignature(signatures, `function ${getIdentifierLikeText(funcDeclarator)}${getParametersText(funcDeclarator)}`);
+            }
+            return;
+        }
+    }
+}

package/dist/src/extractors/csharp.js

@@ -0,0 +1,16 @@
+import { getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addCSharpSignature(node, signatures) {
+    switch (node.type) {
+        case 'class_declaration':
+        case 'interface_declaration':
+        case 'struct_declaration':
+        case 'enum_declaration':
+        case 'record_declaration':
+            pushSignature(signatures, `${node.type.split('_')[0]} ${getIdentifierLikeText(node)}`);
+            return;
+        case 'method_declaration':
+        case 'constructor_declaration':
+            pushSignature(signatures, `method ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/css.js

@@ -0,0 +1,12 @@
+import { findNamedChild, pushSignature } from './utils.js';
+export function addCssFamilySignature(node, signatures) {
+    switch (node.type) {
+        case 'rule_set': {
+            const selectors = findNamedChild(node, new Set(['selectors']));
+            if (selectors) {
+                pushSignature(signatures, `${selectors.text} { ... }`);
+            }
+            return;
+        }
+    }
+}

package/dist/src/extractors/go.js

@@ -0,0 +1,27 @@
+import { getIdentifierLikeText, getNamedFieldText, getParametersText, pushSignature, } from './utils.js';
+export function addGoSignature(node, signatures) {
+    switch (node.type) {
+        case 'function_declaration':
+            pushSignature(signatures, `func ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+        case 'method_declaration':
+            pushSignature(signatures, `method ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+        case 'type_spec': {
+            const name = getIdentifierLikeText(node);
+            const typeText = getNamedFieldText(node, 'type');
+            if (!name)
+                return;
+            if (typeText.startsWith('struct')) {
+                pushSignature(signatures, `type ${name} struct`);
+            }
+            else if (typeText.startsWith('interface')) {
+                pushSignature(signatures, `type ${name} interface`);
+            }
+            else {
+                pushSignature(signatures, `type ${name}`);
+            }
+            return;
+        }
+    }
+}

package/dist/src/extractors/index.js

@@ -0,0 +1,52 @@
+import { addCppFamilySignature } from './cpp.js';
+import { addCSharpSignature } from './csharp.js';
+import { addCssFamilySignature } from './css.js';
+import { addGoSignature } from './go.js';
+import { addJavaSignature } from './java.js';
+import { addJsFamilySignature } from './javascript.js';
+import { addObjcSignature } from './objc.js';
+import { addPhpSignature } from './php.js';
+import { addPythonSignature } from './python.js';
+import { addRubySignature } from './ruby.js';
+import { addRustSignature } from './rust.js';
+export function addSignatureForNode(node, languageId, signatures) {
+    switch (languageId) {
+        case 'javascript':
+        case 'typescript':
+        case 'tsx':
+            addJsFamilySignature(node, signatures);
+            return;
+        case 'python':
+            addPythonSignature(node, signatures);
+            return;
+        case 'go':
+            addGoSignature(node, signatures);
+            return;
+        case 'rust':
+            addRustSignature(node, signatures);
+            return;
+        case 'php':
+            addPhpSignature(node, signatures);
+            return;
+        case 'java':
+            addJavaSignature(node, signatures);
+            return;
+        case 'c':
+        case 'cpp':
+            addCppFamilySignature(node, signatures);
+            return;
+        case 'csharp':
+            addCSharpSignature(node, signatures);
+            return;
+        case 'objc':
+            addObjcSignature(node, signatures);
+            return;
+        case 'ruby':
+            addRubySignature(node, signatures);
+            return;
+        case 'css':
+        case 'scss':
+            addCssFamilySignature(node, signatures);
+            return;
+    }
+}

package/dist/src/extractors/java.js

@@ -0,0 +1,14 @@
+import { getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addJavaSignature(node, signatures) {
+    switch (node.type) {
+        case 'class_declaration':
+        case 'interface_declaration':
+        case 'enum_declaration':
+            pushSignature(signatures, `${node.type.split('_')[0]} ${getIdentifierLikeText(node)}`);
+            return;
+        case 'method_declaration':
+        case 'constructor_declaration':
+            pushSignature(signatures, `method ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/javascript.js

@@ -0,0 +1,33 @@
+import { getIdentifierLikeText, getParametersText, getVariableNameFromFunctionNode, pushSignature, } from './utils.js';
+export function addJsFamilySignature(node, signatures) {
+    switch (node.type) {
+        case 'class_declaration':
+            pushSignature(signatures, `class ${getIdentifierLikeText(node)}`);
+            return;
+        case 'interface_declaration':
+            pushSignature(signatures, `interface ${getIdentifierLikeText(node)}`);
+            return;
+        case 'type_alias_declaration':
+            pushSignature(signatures, `type ${getIdentifierLikeText(node)}`);
+            return;
+        case 'enum_declaration':
+            pushSignature(signatures, `enum ${getIdentifierLikeText(node)}`);
+            return;
+        case 'function_declaration':
+        case 'function_signature':
+            pushSignature(signatures, `function ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+        case 'method_definition':
+        case 'method_signature':
+            pushSignature(signatures, `method ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+        case 'arrow_function':
+        case 'function_expression': {
+            const name = getVariableNameFromFunctionNode(node);
+            if (name) {
+                pushSignature(signatures, `function ${name}${getParametersText(node)}`);
+            }
+            return;
+        }
+    }
+}

package/dist/src/extractors/objc.js

@@ -0,0 +1,14 @@
+import { getIdentifierLikeText, pushSignature } from './utils.js';
+export function addObjcSignature(node, signatures) {
+    switch (node.type) {
+        case 'class_interface':
+        case 'class_implementation':
+        case 'protocol_declaration':
+            pushSignature(signatures, `class ${getIdentifierLikeText(node)}`);
+            return;
+        case 'method_declaration':
+        case 'method_definition':
+            pushSignature(signatures, `method ${getIdentifierLikeText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/php.js

@@ -0,0 +1,20 @@
+import { getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addPhpSignature(node, signatures) {
+    switch (node.type) {
+        case 'class_declaration':
+            pushSignature(signatures, `class ${getIdentifierLikeText(node)}`);
+            return;
+        case 'interface_declaration':
+            pushSignature(signatures, `interface ${getIdentifierLikeText(node)}`);
+            return;
+        case 'trait_declaration':
+            pushSignature(signatures, `trait ${getIdentifierLikeText(node)}`);
+            return;
+        case 'function_definition':
+            pushSignature(signatures, `function ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+        case 'method_declaration':
+            pushSignature(signatures, `method ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/python.js

@@ -0,0 +1,11 @@
+import { getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addPythonSignature(node, signatures) {
+    switch (node.type) {
+        case 'class_definition':
+            pushSignature(signatures, `class ${getIdentifierLikeText(node)}`);
+            return;
+        case 'function_definition':
+            pushSignature(signatures, `def ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/ruby.js

@@ -0,0 +1,13 @@
+import { getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addRubySignature(node, signatures) {
+    switch (node.type) {
+        case 'class':
+        case 'module':
+            pushSignature(signatures, `${node.type} ${getIdentifierLikeText(node)}`);
+            return;
+        case 'method':
+        case 'singleton_method':
+            pushSignature(signatures, `def ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/rust.js

@@ -0,0 +1,17 @@
+import { getIdentifierLikeText, getParametersText, pushSignature, } from './utils.js';
+export function addRustSignature(node, signatures) {
+    switch (node.type) {
+        case 'struct_item':
+            pushSignature(signatures, `struct ${getIdentifierLikeText(node)}`);
+            return;
+        case 'enum_item':
+            pushSignature(signatures, `enum ${getIdentifierLikeText(node)}`);
+            return;
+        case 'trait_item':
+            pushSignature(signatures, `trait ${getIdentifierLikeText(node)}`);
+            return;
+        case 'function_item':
+            pushSignature(signatures, `fn ${getIdentifierLikeText(node)}${getParametersText(node)}`);
+            return;
+    }
+}

package/dist/src/extractors/utils.js

@@ -0,0 +1,58 @@
+export function pushSignature(signatures, line) {
+    const normalized = String(line ?? '').trim();
+    if (!normalized)
+        return;
+    if (!signatures.includes(normalized)) {
+        signatures.push(normalized);
+    }
+}
+export function getNamedFieldText(node, fieldName) {
+    return node?.childForFieldName(fieldName)?.text ?? '';
+}
+export function findNamedChild(node, allowedTypes) {
+    if (!node)
+        return null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && allowedTypes.has(child.type)) {
+            return child;
+        }
+    }
+    return null;
+}
+export function getIdentifierLikeText(node) {
+    if (!node)
+        return '';
+    const directName = getNamedFieldText(node, 'name') ||
+        getNamedFieldText(node, 'declarator') ||
+        getNamedFieldText(node, 'pattern');
+    if (directName)
+        return directName;
+    const identifierNode = findNamedChild(node, new Set([
+        'identifier',
+        'property_identifier',
+        'type_identifier',
+        'variable_name',
+        'name',
+        'namespace_name',
+    ]));
+    return identifierNode?.text ?? '';
+}
+export function getParametersText(node, fallback = '()') {
+    if (!node)
+        return fallback;
+    const fromField = getNamedFieldText(node, 'parameters') ||
+        getNamedFieldText(node, 'parameter') ||
+        getNamedFieldText(node, 'arguments');
+    if (fromField)
+        return fromField;
+    const paramsNode = findNamedChild(node, new Set(['formal_parameters', 'parameters', 'parameter_list']));
+    return paramsNode?.text ?? fallback;
+}
+export function getVariableNameFromFunctionNode(node) {
+    const parent = node?.parent;
+    if (!parent || parent.type !== 'variable_declarator') {
+        return '';
+    }
+    return getNamedFieldText(parent, 'name') || getIdentifierLikeText(parent);
+}

package/dist/src/help-text.js

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+// The bound keys (Enter/Esc/Ctrl+C/Tab/arrows) are identical across platforms in
+// a terminal. The one thing that genuinely differs is the terminal's paste
+// shortcut, so surface the one for the host OS (right-click paste works
+// everywhere regardless).
+function pasteShortcutForPlatform() {
+    switch (process.platform) {
+        case 'darwin':
+            return 'Cmd+V';
+        case 'win32':
+            return 'Ctrl+V';
+        default:
+            return 'Ctrl+Shift+V';
+    }
+}
+const PASTE_SHORTCUT = pasteShortcutForPlatform();
+const HELP_MARKDOWN = [
+    '# TheGitAI',
+    '',
+    'Interactive terminal coding agent. Local repo indexing, file edits, and',
+    'shell commands run on your machine. Model inference and server-executed',
+    'tools run on the server.',
+    '',
+    '## Usage',
+    '',
+    '- `ai` — start an interactive chat session in the current repo',
+    '- `ai "<request>"` — start an interactive session with `<request>` as the first message',
+    '',
+    '## Auth',
+    '',
+    '- `ai login` — sign in to TheGitAI (opens your browser to the website)',
+    '- `ai login --no-browser` — print a URL and paste the code (for SSH/headless)',
+    '- `ai whoami` — show the signed-in account',
+    '- `ai --usage` — show account usage percentage and reset times',
+    '- `ai logout` — sign out',
+    '',
+    '## Sessions',
+    '',
+    '- `ai --list-sessions` — list saved sessions for this repo',
+    '- `ai --session <id|name>` — resume a saved session by id or name',
+    '- Sessions are stored locally and scoped to the current repo. The five',
+    '  most recent sessions per repo are kept.',
+    '',
+    '## Options',
+    '',
+    '- `-y, --yes` — start in Auto-Accept mode',
+    '- `-h, --help` — show this help',
+    '',
+    '## Modes',
+    '',
+    '- Default — asks before shell commands and file edits.',
+    '- Auto-Accept — approves shell commands and file edits for the session.',
+    '- Plan — read-only; the agent can inspect, ask typed questions, and plan,',
+    '  with file-reading shell commands only. It will not edit files or run tests,',
+    '  builds, diagnostics, package managers, project code, or network probes.',
+    '- In the TUI, Shift+Tab cycles modes, mouse drag copies transcript/footer text, left-click opens rendered links, right-click copies rendered links or pastes in the sticky composer/footer when no selection is active, double-click copies a word, and triple-click copies a row.',
+    '',
+    '## Keys & clipboard',
+    '',
+    '- **Enter** sends • **Shift+Tab** cycles modes • **Esc** cancels the turn •',
+    '  **Ctrl+C** quits. These are the same on macOS, Linux, and Windows.',
+    `- **Paste** into the composer with your terminal's paste shortcut (\`${PASTE_SHORTCUT}\``,
+    '  on this system) or by right-clicking the composer.',
+    '- **Copy** from the transcript by dragging to select; double-click copies a',
+    '  word and triple-click copies a row. Left-click opens rendered links.',
+    ...(process.platform === 'darwin'
+        ? ['- On Mac laptops without dedicated keys, **Home/End** are `Fn+←` / `Fn+→`.']
+        : []),
+    '',
+    '## Chat commands',
+    '',
+    '- `/help` — show this help',
+    '- `/usage` — show account usage percentage and reset times',
+    '- `/model` — list supported models and pick one',
+    '- `/model <id>` — switch the active model without clearing history',
+    '- `/resume` — resume a saved session for this repo',
+    '- `/clear` — clear the current conversation history',
+    '- `/exit` — quit the session',
+    '',
+    '## Safety & approvals',
+    '',
+    '- TheGitAI asks before running shell commands or applying file edits.',
+    '- At each prompt: **y** approves once, **a** approves the rest of the',
+    '  session, **n** denies.',
+    '- If an approved `sudo` command needs a password, the TUI shows the exact',
+    '  command and keeps the password masked and local.',
+    '- `-y` / `--yes` at startup auto-approves every shell command and file',
+    '  edit for the whole session — use with care.',
+    '- File and shell operations are confined to the target repo root.',
+    '- Sensitive directories (`.git`, `node_modules`, build output) are',
+    '  never indexed.',
+    '',
+    '## Troubleshooting',
+    '',
+    '- "Not logged in" → run `ai login`.',
+    '- Auth or permission errors → run `ai whoami` to confirm the signed-in',
+    '  account.',
+    '- Usage or quota errors → run `ai --usage`.',
+    '- Stuck on the wrong account → `ai logout`, then `ai login` again.',
+    '- For anything else, re-run the command and report the printed error',
+    '  message — there is no client-side debug mode by design.',
+].join('\n');
+export function formatHelpMarkdown() {
+    return HELP_MARKDOWN;
+}
+export function formatInteractiveHelpText() {
+    return HELP_MARKDOWN;
+}
+export function formatCliHelpText({ color = false } = {}) {
+    if (!color)
+        return HELP_MARKDOWN;
+    return HELP_MARKDOWN.split('\n')
+        .map((line) => {
+        const heading = line.match(/^(#{1,6})\s+(.*)$/);
+        if (heading) {
+            const level = heading[1].length;
+            const text = heading[2] ?? '';
+            return level === 1 ? chalk.bold.cyan(text) : chalk.bold(text);
+        }
+        let styled = line.replace(/`([^`]+)`/g, (_match, code) => chalk.cyan(code));
+        styled = styled.replace(/\*\*([^*]+)\*\*/g, (_match, bold) => chalk.bold(bold));
+        return styled;
+    })
+        .join('\n');
+}

package/dist/src/markdown-renderer.js

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+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();
+}