codeep 2.15.0 → 2.16.0

package/dist/renderer/components/Autocomplete.d.ts

@@ -31,3 +31,28 @@ export interface AutocompleteResult {
  * @returns Match list, or `null` when the dropdown should be hidden.
  */
 export declare function filterCommands(value: string, commands: string[]): AutocompleteResult | null;
+/**
+ * The position and query of an in-progress `@mention`, or `null` when
+ * the cursor isn't inside a mention being typed.
+ *
+ * A mention is "in progress" when, scanning backwards from `cursorPos`:
+ *   1. We find an `@`.
+ *   2. Between `@` and the cursor there are only "path characters"
+ *      (letters, digits, `/`, `.`, `_`, `-`, `\`) and no whitespace.
+ *   3. The `@` itself is at the start of the string OR preceded by a
+ *      boundary char (space, `(`, `[`, …) — so `user@host` doesn't
+ *      count. Mirrors `extractMentions` in `utils/mentions.ts`.
+ */
+export interface MentionQuery {
+    /** Start index of the `@` in the source string. */
+    atStart: number;
+    /** The text typed so far after the `@` (may be empty). */
+    query: string;
+}
+/**
+ * Detect whether the cursor sits inside an `@mention` being typed, and
+ * if so, return the query text (everything after `@`). Pure — no FS.
+ *
+ * Used by the autocomplete layer to know when to show the file picker.
+ */
+export declare function detectMentionQuery(text: string, cursorPos: number): MentionQuery | null;

package/dist/renderer/components/Autocomplete.js

@@ -5,6 +5,7 @@
  * only triggered for command-shaped input) can be unit-tested without
  * the editor / render machinery.
  */
+import { MENTION_BOUNDARY } from '../../utils/mentions.js';
 /**
  * Filter `commands` to those that start with the typed prefix and the
  * dropdown should appear.
@@ -38,3 +39,37 @@ export function filterCommands(value, commands) {
         return { items: [], index: 0 };
     return { items, index: 0 };
 }
+const PATH_CHAR = /[A-Za-z0-9._\/\\-]/;
+/**
+ * Detect whether the cursor sits inside an `@mention` being typed, and
+ * if so, return the query text (everything after `@`). Pure — no FS.
+ *
+ * Used by the autocomplete layer to know when to show the file picker.
+ */
+export function detectMentionQuery(text, cursorPos) {
+    if (cursorPos < 1 || cursorPos > text.length)
+        return null;
+    // Scan backwards from the cursor, collecting path chars until we hit `@`.
+    let i = cursorPos - 1;
+    let query = '';
+    while (i >= 0) {
+        const ch = text[i];
+        if (ch === '@') {
+            // Found the `@`. Check the preceding char is a boundary (or start).
+            // Boundary set mirrors `extractMentions` in `utils/mentions.ts`.
+            const before = i > 0 ? text[i - 1] : '';
+            // Keep in lockstep with `MENTION_RE`'s lookbehind in utils/mentions.ts.
+            // If this set is looser, the picker offers a completion the expander
+            // then refuses to treat as a mention and the file is never attached.
+            if (before === '' || MENTION_BOUNDARY.test(before)) {
+                return { atStart: i, query };
+            }
+            return null; // `@` not at a boundary → email/handle, not a mention.
+        }
+        if (!PATH_CHAR.test(ch))
+            return null; // hit a non-path char before `@`.
+        query = ch + query;
+        i--;
+    }
+    return null; // no `@` found before the cursor.
+}

package/dist/renderer/layout.d.ts

@@ -38,6 +38,9 @@ export interface LayoutSnapshot {
     readonly settingsCount: number;
     readonly showAutocomplete: boolean;
     readonly autocompleteItemCount: number;
+    readonly hunkPickerOpen: boolean;
+    readonly mentionPickerOpen: boolean;
+    readonly mentionItemCount: number;
 }
 /**
  * Compute how many terminal rows the bottom panel (paste info, agent box,
@@ -144,7 +147,7 @@ export declare function statusBarRightHint(args: {
     isLoading: boolean;
 }): string;
 /** The panel that currently owns keyboard focus, in priority order. */
-export type ActivePanel = 'pasteInfo' | 'permission' | 'sessionPicker' | 'confirm' | 'status' | 'help' | 'settings' | 'search' | 'export' | 'logout' | 'login' | 'menu' | 'autocomplete' | 'chat';
+export type ActivePanel = 'pasteInfo' | 'permission' | 'sessionPicker' | 'confirm' | 'status' | 'help' | 'settings' | 'search' | 'export' | 'logout' | 'login' | 'menu' | 'autocomplete' | 'hunkPicker' | 'chat';
 export interface PanelState {
     readonly pasteInfoOpen: boolean;
     readonly permissionOpen: boolean;
@@ -159,6 +162,7 @@ export interface PanelState {
     readonly loginOpen: boolean;
     readonly menuOpen: boolean;
     readonly showAutocomplete: boolean;
+    readonly hunkPickerOpen: boolean;
 }
 /**
  * Return the highest-priority open panel. `chat` is the fallback when no

package/dist/renderer/layout.js

@@ -36,6 +36,10 @@ export function bottomPanelHeight(s) {
     if (s.confirmOpen) {
         return s.confirmMessageCount + 5; // title + messages + buttons + padding
     }
+    if (s.hunkPickerOpen) {
+        // Title + progress + path + header + up to 12 diff lines + more marker + legend.
+        return 18;
+    }
     if (s.statusOpen) {
         return 16; // Status info panel
     }
@@ -65,6 +69,12 @@ export function bottomPanelHeight(s) {
     if (s.showAutocomplete && s.autocompleteItemCount > 0) {
         return Math.min(s.autocompleteItemCount + 3, 12);
     }
+    // `@`-mention picker: separator + title + up to 8 rows + footer. Without
+    // this branch the panel measured 0 while the picker still painted its rows,
+    // so it drew straight over the bottom of the chat transcript.
+    if (s.mentionPickerOpen && s.mentionItemCount > 0) {
+        return Math.min(s.mentionItemCount, 8) + 3;
+    }
     return 0;
 }
 export function chatLayout(height, panelHeight) {
@@ -237,6 +247,8 @@ export function activePanel(s) {
         return 'login';
     if (s.menuOpen)
         return 'menu';
+    if (s.hunkPickerOpen)
+        return 'hunkPicker';
     if (s.showAutocomplete)
         return 'autocomplete';
     return 'chat';

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';
@@ -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();

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/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;

package/dist/utils/git.js

@@ -1,4 +1,4 @@
-import { execSync, spawnSync } from 'child_process';
+import { execSync, execFileSync, spawnSync } from 'child_process';
 import { existsSync } from 'fs';
 import { join } from 'path';
 /**
@@ -397,3 +397,113 @@ export function createBranchAndCommit(prompt, actions, cwd = process.cwd()) {
         hash: commitResult.hash,
     };
 }
+/** Max bytes we'll inline from a single `@git` mention. */
+export const MAX_GIT_BYTES = 64 * 1024;
+/**
+ * Characters a git ref/pathspec may contain for `@git` mentions. Deliberately
+ * conservative: word chars plus the punctuation real refs use
+ * (`main..feature`, `HEAD~3`, `v1.2.0^{}`, `main:src/x.ts`, `origin/main`).
+ * A leading `-` is rejected separately so a ref can never be read as a flag.
+ */
+const SAFE_GIT_REF = /^[A-Za-z0-9._/:~^@{}-]+$/;
+export function isSafeGitRef(token) {
+    return token.length > 0 && !token.startsWith('-') && SAFE_GIT_REF.test(token);
+}
+/**
+ * The only flags `@git diff …` may pass through. An allowlist rather than a
+ * deny-list because several git flags write files or run commands
+ * (`--output=`, `--ext-diff`), which would turn a mention into a side effect.
+ */
+const GIT_DIFF_FLAG_ALLOWLIST = new Set([
+    '--staged', '--cached', '--stat', '--numstat', '--shortstat',
+    '--name-only', '--name-status', '--patch', '-p', '--no-color',
+]);
+/**
+ * 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 function getGitContent(ref, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return { success: false, content: '', label: ref, error: 'not a git repository' };
+    }
+    const trimmed = ref.trim();
+    if (!trimmed) {
+        return { success: false, content: '', label: ref, error: 'empty git ref' };
+    }
+    // Pick the git subcommand based on the ref shape. NOTE: the ref comes from
+    // free-form prompt text (`@git <ref>`), which may be pasted from an issue,
+    // a log, or model output — so it is UNTRUSTED. We therefore (a) build an
+    // argv array and spawn git directly with `execFileSync` (no `/bin/sh`, so
+    // `;`, `|`, backticks and friends are inert), and (b) validate every token,
+    // because argv alone doesn't stop *argument* injection — a ref that starts
+    // with `-` would still be read by git as a flag (e.g. `--output=…` writes a
+    // file). Anything unrecognized is rejected rather than guessed at.
+    let args;
+    let label;
+    if (trimmed === 'diff') {
+        args = ['diff'];
+        label = 'diff (unstaged)';
+    }
+    else if (trimmed === 'diff --staged' || trimmed === 'diff --cached' || trimmed === 'staged') {
+        args = ['diff', '--cached'];
+        label = 'diff (staged)';
+    }
+    else if (trimmed.startsWith('diff ')) {
+        // e.g. `diff main..feature` or `diff HEAD~3` or `diff --stat`
+        const rest = trimmed.slice('diff '.length).trim();
+        const tokens = rest.split(/\s+/).filter(Boolean);
+        const bad = tokens.find(t => !(isSafeGitRef(t) || GIT_DIFF_FLAG_ALLOWLIST.has(t)));
+        if (bad) {
+            return { success: false, content: '', label: ref, error: `unsupported git argument: ${bad}` };
+        }
+        args = ['diff', ...tokens];
+        label = `diff (${rest})`;
+    }
+    else if (trimmed === 'HEAD' || trimmed === '@') {
+        // Show the latest commit's patch.
+        args = ['show', 'HEAD'];
+        label = 'HEAD';
+    }
+    else {
+        // Any other ref → `git show`. Works for SHAs, tags, branches, and
+        // `<ref>:<path>` (file-at-ref) forms.
+        if (!isSafeGitRef(trimmed)) {
+            return { success: false, content: '', label: ref, error: `unsupported git ref: ${trimmed}` };
+        }
+        args = ['show', trimmed];
+        label = trimmed;
+    }
+    try {
+        const out = execFileSync('git', args, {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        const content = (out ?? '').trimEnd();
+        if (!content) {
+            return { success: false, content: '', label, error: 'empty result (no changes / unknown ref)' };
+        }
+        // Truncate to the cap so a massive diff can't blow the context.
+        const capped = content.length > MAX_GIT_BYTES
+            ? content.slice(0, MAX_GIT_BYTES) + `\n\n… (truncated at ${MAX_GIT_BYTES / 1024}KB)`
+            : content;
+        return { success: true, content: capped, label };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        // git show exits non-zero on unknown refs; surface a friendly reason.
+        const reason = /unknown revision|bad revision|ambiguous argument/i.test(msg)
+            ? `unknown git ref: ${trimmed}`
+            : msg;
+        return { success: false, content: '', label, error: reason };
+    }
+}