codeep 2.14.0 → 2.16.0

package/dist/renderer/main.js

@@ -20,6 +20,8 @@ import { getSessionStats, getCostBreakdown } from '../utils/tokenTracker.js';
 import { isGitRepository } from '../utils/git.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
 import { checkApiRateLimit } from '../utils/ratelimit.js';
+import { expandFileAndFolderMentions, expandGitMentions } from '../utils/mentions.js';
+import { expandWebMentions } from '../utils/webFetch.js';
 import { handleCommand as dispatchCommand } from './commands.js';
 import { logAppError } from '../utils/logger.js';
 import { executeAgentTask, runAgentTask, } from './agentExecution.js';
@@ -33,7 +35,7 @@ let app;
 let sessionDisplayName = null;
 const addedFiles = new Map();
 /** Derive a short display name from a user message (first ~5 words, max 48 chars). */
-function deriveSessionName(message) {
+export function deriveSessionName(message) {
     const clean = message.replace(/\s+/g, ' ').trim();
     const words = clean.split(' ').slice(0, 5).join(' ');
     return words.length > 48 ? words.slice(0, 45) + '…' : words;
@@ -163,11 +165,41 @@ async function handleSubmit(message) {
     try {
         app.startStreaming();
         const history = app.getChatHistory();
+        // Expand inline @-mentions (@src/file.ts) into the prompt's context.
+        // Done after history capture (mentions are per-message) but before
+        // deriveSessionName so the title reflects what the user typed, not the
+        // expanded path.
+        const mentionRoot = projectContext?.root || projectPath || process.cwd();
+        // Expand @folder and @file mentions in one pass, merged into a single
+        // [Attached files] block.
+        const { enrichedPrompt: fileExpanded, loaded: loadedMentions, failures: mentionFailures } = expandFileAndFolderMentions(message, { root: mentionRoot });
+        if (loadedMentions.length > 0) {
+            app.notify(`Loaded ${loadedMentions.length} file(s) from @mentions/@folder`);
+        }
+        for (const f of mentionFailures) {
+            app.notify(`${f.mention}: ${f.reason}`);
+        }
+        // Expand @git <ref> mentions — resolve diffs / file-at-ref / commit
+        // patches into a [Git ref] block. Runs between file and web mentions
+        // so the prompt flows: [files] [git] [web] <text>.
+        const { enrichedPrompt: gitExpanded, failures: gitFailures } = await expandGitMentions(fileExpanded, { root: mentionRoot });
+        for (const f of gitFailures) {
+            app.notify(`${f.mention}: ${f.reason}`);
+        }
+        // Expand @web <url> mentions — fetch each page and prepend its text.
+        // Runs after file mentions so the prompt flows: [files] [web] <text>.
+        const { enrichedPrompt: webExpanded, loaded: loadedPages, failures: webFailures } = await expandWebMentions(gitExpanded);
+        if (loadedPages.length > 0) {
+            app.notify(`Fetched ${loadedPages.length} page(s) from @web`);
+        }
+        for (const f of webFailures) {
+            app.notify(`${f.mention}: ${f.reason}`);
+        }
         if (!sessionDisplayName && history.filter(m => m.role === 'user').length === 0) {
             sessionDisplayName = deriveSessionName(message);
         }
         const fileContext = formatAddedFilesContext();
-        const enrichedMessage = fileContext ? fileContext + message : message;
+        const enrichedMessage = fileContext ? fileContext + webExpanded : webExpanded;
         await chat(enrichedMessage, history, (chunk) => app.addStreamChunk(chunk), undefined, projectContext, undefined);
         app.endStreaming();
         autoSaveSession(app.getMessages(), projectPath);
@@ -621,6 +653,7 @@ Commands (in chat):
         getStatus,
         hasWriteAccess: () => hasWriteAccess,
         hasProjectContext: () => projectContext !== null,
+        getProjectRoot: () => projectContext?.root || projectPath || process.cwd(),
     });
     const provider = getCurrentProvider();
     const providers = getProviderList();
@@ -706,18 +739,53 @@ Commands (in chat):
     if (projectPath) {
         (async () => {
             try {
-                const { loadMcpServerConfig } = await import('../utils/mcpConfig.js');
+                const { loadMcpServerConfigSplit, isWorkspaceMcpTrusted, trustWorkspaceMcp } = await import('../utils/mcpConfig.js');
                 const { registerSessionServers } = await import('../utils/mcpRegistry.js');
-                const servers = loadMcpServerConfig(projectPath);
-                if (servers.length === 0)
+                const { global: globalServers, workspace: workspaceServers } = loadMcpServerConfigSplit(projectPath);
+                const spawnServers = async (servers) => {
+                    if (servers.length === 0)
+                        return;
+                    const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: projectPath });
+                    if (registered.length > 0) {
+                        app.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
+                    }
+                    for (const e of errors) {
+                        app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
+                    }
+                };
+                // ~/.codeep servers are the user's own machine-wide config — spawn.
+                await spawnServers(globalServers);
+                // Workspace files (.codeep/mcp_servers.json, .mcp.json) travel WITH
+                // the repo — a cloned project could otherwise execute arbitrary
+                // commands at startup. One-time per-workspace approval, mirroring
+                // the trustedHookProjects gate for hooks.
+                if (workspaceServers.length === 0)
+                    return;
+                if (isWorkspaceMcpTrusted(projectPath)) {
+                    await spawnServers(workspaceServers);
                     return;
-                const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: projectPath });
-                if (registered.length > 0) {
-                    app.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
-                }
-                for (const e of errors) {
-                    app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
                 }
+                const preview = workspaceServers.slice(0, 5).map(s => `  ${s.name}: ${s.command ? [s.command, ...(s.args ?? [])].join(' ') : s.url ?? ''}`);
+                if (workspaceServers.length > 5)
+                    preview.push(`  …and ${workspaceServers.length - 5} more`);
+                app.showConfirm({
+                    title: 'Trust workspace MCP servers?',
+                    message: [
+                        `This workspace defines ${workspaceServers.length} MCP server(s) that run as local processes:`,
+                        ...preview,
+                        '',
+                        'Only start them if you trust this repo — they run with your permissions.',
+                    ],
+                    confirmLabel: 'Trust & start',
+                    cancelLabel: 'Not now',
+                    onConfirm: () => {
+                        trustWorkspaceMcp(projectPath);
+                        void spawnServers(workspaceServers);
+                    },
+                    onCancel: () => {
+                        app.notify('Workspace MCP servers skipped. Run /mcp trust to enable them.');
+                    },
+                });
             }
             catch {
                 // Loading MCP must never block the TUI.

package/dist/renderer/ollamaHint.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Return a UI hint for an Ollama model id, based on its parameter count.
+ *
+ * Examples:
+ *   - `7b`, `8b`, `14b`, `72b` → `'✓ agent mode'`
+ *   - `1.5b`, `3b`            → `'⚠ chat only (< 7B)'`
+ *   - `custom-name` (no size) → `''` (no hint)
+ *
+ * The parameter count is parsed from the first `<number>b` token in the
+ * id (case-insensitive), so both `qwen3:14b` and `llama2-13b` work.
+ */
+export declare function ollamaModelHint(modelId: string): string;

package/dist/renderer/ollamaHint.js

@@ -0,0 +1,29 @@
+/**
+ * Ollama model-size hint.
+ *
+ * Extracted from `commands.ts` so the size threshold + label rule can be
+ * unit-tested. Maps a model id like `qwen3:14b` to a UI hint telling the
+ * user whether the model is agent-capable (≥ 7B params) or chat-only.
+ */
+const AGENT_MIN_PARAMS_B = 7;
+/**
+ * Return a UI hint for an Ollama model id, based on its parameter count.
+ *
+ * Examples:
+ *   - `7b`, `8b`, `14b`, `72b` → `'✓ agent mode'`
+ *   - `1.5b`, `3b`            → `'⚠ chat only (< 7B)'`
+ *   - `custom-name` (no size) → `''` (no hint)
+ *
+ * The parameter count is parsed from the first `<number>b` token in the
+ * id (case-insensitive), so both `qwen3:14b` and `llama2-13b` work.
+ */
+export function ollamaModelHint(modelId) {
+    const lower = modelId.toLowerCase();
+    const match = lower.match(/(\d+(?:\.\d+)?)b/);
+    if (!match)
+        return '';
+    const params = parseFloat(match[1]);
+    if (params >= AGENT_MIN_PARAMS_B)
+        return '✓ agent mode';
+    return '⚠ chat only (< 7B)';
+}

package/dist/utils/agentChat.js

@@ -43,15 +43,37 @@ export class TimeoutError extends Error {
  * Load project rules from .codeep/rules.md or CODEEP.md
  */
 export function loadProjectRules(projectRoot) {
+    // Lookup precedence (highest first):
+    //   1. .codeep/rules.md  — Codeep-native, committed with the repo
+    //   2. CODEEP.md         — Codeep-native, root-level convenience
+    //   3. AGENTS.md         — cross-tool standard (Claude Code, Cursor,
+    //                          Kilo Code). Read so users coming from those
+    //                          tools don't have to duplicate their rules.
+    //
+    // First non-empty file wins. We deliberately don't concatenate: when two
+    // files exist, the Codeep-native one is authoritative (a user who keeps
+    // both probably has a trimmed AGENTS.md for the other tools and a richer
+    // CODEEP-specific rules file here).
     const candidates = [
         join(projectRoot, '.codeep', 'rules.md'),
         join(projectRoot, 'CODEEP.md'),
+        join(projectRoot, 'AGENTS.md'),
     ];
+    // Rules ride EVERY system prompt, so cap the injected size — an oversized
+    // file (AGENTS.md files from other tools can grow unbounded) would bloat
+    // every request's token bill and can push small-context models over their
+    // limit. 64KB ≈ 16k tokens is far above any sane rules file.
+    const MAX_RULES_BYTES = 64 * 1024;
     for (const filePath of candidates) {
         if (existsSync(filePath)) {
             try {
-                const content = readFileSync(filePath, 'utf-8').trim();
+                let content = readFileSync(filePath, 'utf-8').trim();
                 if (content) {
+                    if (content.length > MAX_RULES_BYTES) {
+                        debug('Project rules truncated', filePath, `${content.length} > ${MAX_RULES_BYTES}`);
+                        content = content.slice(0, MAX_RULES_BYTES)
+                            + '\n\n[Rules truncated by Codeep — file exceeds the 64KB inline limit.]';
+                    }
                     debug('Loaded project rules from', filePath);
                     return `\n\n## Project Rules\nThe following rules are defined by the project owner. You MUST follow these rules:\n\n${content}`;
                 }

package/dist/utils/codeepCloud.d.ts

@@ -77,6 +77,13 @@ export declare function pushKeys(keys: Record<string, string>): Promise<boolean>
  * later wants them off the server. Returns true on success.
  */
 export declare function purgeKeys(): Promise<boolean>;
+declare function globalDir(kind: 'personalities' | 'commands'): string;
+/** Read every <name>.md in a global config dir into a { name → body } map. */
+declare function readFileBundle(kind: 'personalities' | 'commands'): Record<string, string>;
+/** Write a { name → body } map into a global config dir as <name>.md
+ *  files. Only writes files that don't already exist (additive merge —
+ *  never clobber local edits). Returns the count of newly written files. */
+declare function writeFileBundle(kind: 'personalities' | 'commands', items: Record<string, string>): number;
 export declare const pullPersonalities: () => Promise<number | null>;
 export declare const pushPersonalities: () => Promise<number | null>;
 export declare const pullCommands: () => Promise<number | null>;
@@ -106,6 +113,49 @@ export declare function syncSessionAsync(payload: {
         content: string;
     }[];
 }): Promise<void>;
+/** Summary of a remote session — no messages, just metadata for listing. */
+export interface CloudSessionSummary {
+    sessionId: string;
+    sessionName: string | null;
+    projectName: string | null;
+    projectId: string | null;
+    messageCount: number;
+    updatedAt: string;
+}
+/** Full remote session — messages included (fetched on demand by id). */
+export interface CloudSession extends CloudSessionSummary {
+    messages: {
+        role: string;
+        content: string;
+    }[];
+}
+/**
+ * List the user's cloud sessions (summaries only — no message bodies).
+ *
+ * The server supports three scopes via the `projectId` query param:
+ *   - omitted    → all sessions for the user
+ *   - "none"     → only personal (no-project) sessions
+ *   - <id>       → sessions scoped to that project
+ *
+ * Returns null if not linked or on network/server error. The caller decides
+ * how to surface that (silently skip vs. notify).
+ *
+ * `telemetry` is NOT consulted here — reading your own previously-pushed
+ * data back is not telemetry, and the user is explicitly asking for it
+ * (via /cloud). The original push was already gated.
+ */
+export declare function listCloudSessions(projectId?: string): Promise<CloudSessionSummary[] | null>;
+/**
+ * Fetch a single cloud session by id, including the full message array.
+ *
+ * Used by `/cloud` → pick → resume: we pull the messages and write them
+ * into the local `.codeep/sessions/` store via `saveSession`, so the
+ * resumed session behaves identically to a locally-created one (shows
+ * up in `/sessions`, survives restarts, re-syncs on next change).
+ *
+ * Returns null if not linked, not found (404), or network/server error.
+ */
+export declare function pullCloudSession(sessionId: string): Promise<CloudSession | null>;
 /**
  * Sync progress.md content to codeep.dev.
  * Fire-and-forget. Only sends if linked (githubId + syncToken).
@@ -128,3 +178,7 @@ export declare function pushUserProfile(): Promise<boolean>;
  *  exists. Returns 1 if written, 0 if skipped, null on error / not linked. */
 export declare function pullUserProfile(): Promise<number | null>;
 export declare function syncMemoryNotes(projectName: string, notes: string[]): Promise<void>;
+export declare const _globalDirForTest: typeof globalDir;
+export declare const _readFileBundleForTest: typeof readFileBundle;
+export declare const _writeFileBundleForTest: typeof writeFileBundle;
+export {};

package/dist/utils/codeepCloud.js

@@ -372,6 +372,95 @@ export async function syncSessionAsync(payload) {
         body: JSON.stringify({ ...payload, messages: filtered, githubId }),
     });
 }
+/**
+ * List the user's cloud sessions (summaries only — no message bodies).
+ *
+ * The server supports three scopes via the `projectId` query param:
+ *   - omitted    → all sessions for the user
+ *   - "none"     → only personal (no-project) sessions
+ *   - <id>       → sessions scoped to that project
+ *
+ * Returns null if not linked or on network/server error. The caller decides
+ * how to surface that (silently skip vs. notify).
+ *
+ * `telemetry` is NOT consulted here — reading your own previously-pushed
+ * data back is not telemetry, and the user is explicitly asking for it
+ * (via /cloud). The original push was already gated.
+ */
+export async function listCloudSessions(projectId) {
+    const syncToken = getSyncToken();
+    if (!syncToken)
+        return null;
+    const url = new URL(`${API_BASE}/api/sessions`);
+    if (projectId)
+        url.searchParams.set('projectId', projectId);
+    try {
+        const res = await fetch(url.toString(), {
+            headers: { 'x-sync-token': syncToken },
+        });
+        if (!res.ok)
+            return null;
+        // Server responses are untrusted input — validate the shape instead of
+        // casting, so a malformed/hostile payload degrades to null (the normal
+        // "unavailable" path) rather than throwing deep inside the /cloud picker.
+        // Note `!== true` + Array.isArray also normalizes an absent field to
+        // null (a bare `data.ok ? … : null` would leak `undefined` past the
+        // caller's `=== null` check).
+        const data = await res.json();
+        if (data?.ok !== true || !Array.isArray(data.sessions))
+            return null;
+        return data.sessions.filter((s) => {
+            const c = s;
+            return !!c && typeof c === 'object' && typeof c.sessionId === 'string' && c.sessionId.length > 0;
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetch a single cloud session by id, including the full message array.
+ *
+ * Used by `/cloud` → pick → resume: we pull the messages and write them
+ * into the local `.codeep/sessions/` store via `saveSession`, so the
+ * resumed session behaves identically to a locally-created one (shows
+ * up in `/sessions`, survives restarts, re-syncs on next change).
+ *
+ * Returns null if not linked, not found (404), or network/server error.
+ */
+export async function pullCloudSession(sessionId) {
+    const syncToken = getSyncToken();
+    if (!syncToken)
+        return null;
+    try {
+        const url = new URL(`${API_BASE}/api/sessions`);
+        url.searchParams.set('id', sessionId);
+        const res = await fetch(url.toString(), {
+            headers: { 'x-sync-token': syncToken },
+        });
+        if (!res.ok)
+            return null;
+        // Untrusted input — validate before it flows into the local session
+        // store. Messages are filtered to well-formed {role, content} string
+        // pairs; anything else is dropped rather than persisted.
+        const data = await res.json();
+        if (data?.ok !== true || !data.session || typeof data.session !== 'object')
+            return null;
+        const s = data.session;
+        if (typeof s.sessionId !== 'string' || s.sessionId.length === 0)
+            return null;
+        if (!Array.isArray(s.messages))
+            return null;
+        const messages = s.messages.filter((m) => {
+            const c = m;
+            return !!c && typeof c === 'object' && typeof c.role === 'string' && typeof c.content === 'string';
+        });
+        return { ...s, messages };
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Progress log sync ────────────────────────────────────────────────────────
 /**
  * Sync progress.md content to codeep.dev.
@@ -549,3 +638,9 @@ async function fetchWithRetry(url, options, maxRetries = 2) {
     }
     return null;
 }
+// Test seams — these helpers are otherwise file-private; export them under
+// a `_forTest` suffix so the bundle read/write logic can be exercised
+// directly without going through the network round-trip.
+export const _globalDirForTest = globalDir;
+export const _readFileBundleForTest = readFileBundle;
+export const _writeFileBundleForTest = writeFileBundle;

package/dist/utils/diffPreview.d.ts

@@ -55,3 +55,34 @@ export declare function formatDiffPreview(diffs: FileDiff[]): string;
  * Calculate diff statistics
  */
 export declare function getDiffStats(diffs: FileDiff[]): DiffPreviewResult;
+/**
+ * Apply a subset of a file diff's hunks to the original content.
+ *
+ * Hunk indices in `acceptedHunks` refer to positions in `diff.hunks`
+ * (0-based). Hunks not in the set are skipped — their original lines
+ * stay, their additions are dropped.
+ *
+ * Returns the resulting file content. The caller writes it to disk.
+ *
+ * For `type === 'create'`, the whole file is either accepted (any hunk
+ * accepted) or rejected (empty set) — there's no original to merge
+ * against. For `type === 'delete'`, accepting any hunk deletes the file.
+ */
+export declare function applyHunks(diff: FileDiff, acceptedHunks: Set<number>): string;
+/**
+ * Apply accepted hunks across multiple file diffs and return the
+ * resulting content for each. The caller writes the files to disk.
+ *
+ * `accepted` maps file path → set of accepted hunk indices. Files not
+ * in the map are skipped entirely.
+ */
+export declare function applyHunksToFiles(diffs: FileDiff[], accepted: Map<string, Set<number>>): Array<{
+    path: string;
+    content: string;
+    type: FileDiff['type'];
+}>;
+/**
+ * Count how many hunks in a diff contain actual changes (not just
+ * context). Used to label hunks in the UI ("hunk 2/5").
+ */
+export declare function countChangeHunks(diff: FileDiff): number;

package/dist/utils/diffPreview.js

@@ -404,3 +404,105 @@ export function getDiffStats(diffs) {
         totalFiles: diffs.length,
     };
 }
+// ─── Selective apply (per-hunk accept/reject) ───────────────────────────────
+/**
+ * Apply a subset of a file diff's hunks to the original content.
+ *
+ * Hunk indices in `acceptedHunks` refer to positions in `diff.hunks`
+ * (0-based). Hunks not in the set are skipped — their original lines
+ * stay, their additions are dropped.
+ *
+ * Returns the resulting file content. The caller writes it to disk.
+ *
+ * For `type === 'create'`, the whole file is either accepted (any hunk
+ * accepted) or rejected (empty set) — there's no original to merge
+ * against. For `type === 'delete'`, accepting any hunk deletes the file.
+ */
+export function applyHunks(diff, acceptedHunks) {
+    // Create: accept-all-or-nothing — there's no original content to
+    // selectively merge into.
+    if (diff.type === 'create') {
+        return acceptedHunks.size > 0 ? (diff.newContent ?? '') : (diff.oldContent ?? '');
+    }
+    const oldLines = (diff.oldContent ?? '').split('\n');
+    // No accepted hunks → original content unchanged.
+    if (acceptedHunks.size === 0) {
+        return oldLines.join('\n');
+    }
+    const acceptedHunkList = diff.hunks
+        .map((h, i) => ({ hunk: h, index: i }))
+        .filter(({ index }) => acceptedHunks.has(index));
+    // Per-original-line union model.
+    //
+    // The obvious implementation — walk the hunks in order, copying original
+    // lines between them and replaying each hunk's line list — is wrong for
+    // hunks that sit close together, because unified-diff context OVERLAPS:
+    // hunk N's trailing context is hunk N+1's leading context, so the shared
+    // lines get emitted twice. Worse, with a small gap a later hunk's `remove`
+    // can fall *inside* an earlier hunk's already-emitted context, so the
+    // deletion is silently lost. Both corrupt the user's file on `/apply`.
+    //
+    // Instead reduce every accepted hunk to two facts per original line — is it
+    // removed, and what is inserted after it — then rebuild the file once.
+    // Overlap becomes a set union rather than double emission, and the result
+    // is independent of hunk order.
+    const removed = new Set(); // old line numbers deleted
+    const insertAfter = new Map(); // old line number → inserted lines (0 = file head)
+    for (const { hunk } of acceptedHunkList) {
+        // Adds before any context in this hunk belong right before its start,
+        // not at the top of the file.
+        let anchor = Math.max(0, hunk.oldStart - 1);
+        for (const line of hunk.lines) {
+            if (line.type === 'add') {
+                const at = insertAfter.get(anchor);
+                if (at)
+                    at.push(line.content);
+                else
+                    insertAfter.set(anchor, [line.content]);
+                continue;
+            }
+            if (line.oldLineNum === undefined)
+                continue;
+            anchor = line.oldLineNum;
+            if (line.type === 'remove')
+                removed.add(line.oldLineNum);
+        }
+    }
+    const result = [];
+    for (const head of insertAfter.get(0) ?? [])
+        result.push(head);
+    for (let n = 1; n <= oldLines.length; n++) {
+        if (!removed.has(n))
+            result.push(oldLines[n - 1]);
+        const added = insertAfter.get(n);
+        if (added)
+            for (const line of added)
+                result.push(line);
+    }
+    return result.join('\n');
+}
+/**
+ * Apply accepted hunks across multiple file diffs and return the
+ * resulting content for each. The caller writes the files to disk.
+ *
+ * `accepted` maps file path → set of accepted hunk indices. Files not
+ * in the map are skipped entirely.
+ */
+export function applyHunksToFiles(diffs, accepted) {
+    const results = [];
+    for (const diff of diffs) {
+        const acceptedSet = accepted.get(diff.path);
+        if (!acceptedSet)
+            continue;
+        const content = applyHunks(diff, acceptedSet);
+        results.push({ path: diff.path, content, type: diff.type });
+    }
+    return results;
+}
+/**
+ * Count how many hunks in a diff contain actual changes (not just
+ * context). Used to label hunks in the UI ("hunk 2/5").
+ */
+export function countChangeHunks(diff) {
+    return diff.hunks.filter((h) => h.lines.some((l) => l.type === 'add' || l.type === 'remove')).length;
+}

package/dist/utils/export.d.ts

@@ -5,6 +5,18 @@ export interface ExportOptions {
     sessionName?: string;
     timestamp?: string;
 }
+/**
+ * Export messages to Markdown format
+ */
+export declare function exportToMarkdown(messages: Message[], sessionName?: string): string;
+/**
+ * Export messages to JSON format
+ */
+export declare function exportToJson(messages: Message[], sessionName?: string): string;
+/**
+ * Export messages to plain text format
+ */
+export declare function exportToText(messages: Message[], sessionName?: string): string;
 /**
  * Export messages to specified format
  */

package/dist/utils/export.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 /**
  * Export messages to Markdown format
  */
-function exportToMarkdown(messages, sessionName) {
+export function exportToMarkdown(messages, sessionName) {
     const timestamp = new Date().toLocaleString('hr-HR');
     let markdown = `# Codeep Chat Export\n\n`;
     if (sessionName) {
@@ -24,7 +24,7 @@ function exportToMarkdown(messages, sessionName) {
 /**
  * Export messages to JSON format
  */
-function exportToJson(messages, sessionName) {
+export function exportToJson(messages, sessionName) {
     const exportData = {
         session: sessionName || 'Unnamed',
         exportedAt: new Date().toISOString(),
@@ -36,7 +36,7 @@ function exportToJson(messages, sessionName) {
 /**
  * Export messages to plain text format
  */
-function exportToText(messages, sessionName) {
+export function exportToText(messages, sessionName) {
     const timestamp = new Date().toLocaleString('hr-HR');
     let text = `Codeep Chat Export\n`;
     text += `===================\n\n`;

package/dist/utils/git.d.ts

@@ -83,3 +83,31 @@ export declare function createBranchAndCommit(prompt: string, actions: ActionLog
     hash?: string;
     error?: string;
 };
+/**
+ * Result of resolving a `@git <ref>` mention.
+ */
+export interface GitContentResult {
+    success: boolean;
+    /** Raw output from git (diff text, file content, or commit metadata). */
+    content: string;
+    /** A short label for the [Attached files]-style block header. */
+    label: string;
+    error?: string;
+}
+/** Max bytes we'll inline from a single `@git` mention. */
+export declare const MAX_GIT_BYTES: number;
+export declare function isSafeGitRef(token: string): boolean;
+/**
+ * Resolve a `@git <ref>` mention to inline content. The `ref` can be:
+ *
+ * - `diff`           — unstaged changes (`git diff`)
+ * - `diff --staged`  — staged changes (`git diff --cached`)
+ * - `diff a..b`      — diff between two refs (`git diff a..b`)
+ * - `HEAD`           — the latest commit's full diff vs its parent
+ * - `<sha>`          — a specific commit's patch (`git show <sha>`)
+ * - `<ref>:<path>`   — a file at a ref (`git show main:src/x.ts`)
+ * - `<ref>`          — any other git ref → `git show`
+ *
+ * Sync (spawn-based) so it slots into the mention-expansion pipeline.
+ */
+export declare function getGitContent(ref: string, cwd?: string): GitContentResult;