codeep 2.15.0 → 2.17.0

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 };
+    }
+}

package/dist/utils/mentions.d.ts

@@ -0,0 +1,195 @@
+/**
+ * `@-mention` context expansion for the CLI chat input.
+ *
+ * When the user types `@path/to/file.ts` inline in their prompt, we
+ * detect those mentions, read the file contents, and inject them as an
+ * "[Attached files]" block prepended to the prompt — same format as the
+ * explicit `/add` command, so the agent sees a single, consistent shape.
+ *
+ * Supported mention forms (case-sensitive `@`):
+ *   @src/index.ts          → relative-to-project-root file
+ *   @./local.ts            → relative-to-cwd file
+ *   @/abs/path.ts          → absolute path
+ *   @"path with space.ts"  → quoted (spaces/special chars allowed)
+ *   @'path with space.ts'  → single-quoted variant
+ *
+ * A `@` immediately followed by whitespace, another `@`, or a non-path
+ * character (e.g. an email like `user@host`, or a GitHub `@handle`) is
+ * left untouched.
+ *
+ * Mentions are resolved against the project root (or cwd when no
+ * project is open). Files larger than `MAX_MENTION_BYTES` are skipped
+ * with a warning rather than silently truncated — the user should
+ * explicitly `/add` very large files if they really want them.
+ */
+/** Max file size we'll auto-inline from a mention (100 KB). */
+export declare const MAX_MENTION_BYTES: number;
+/** Result of expanding `@-mentions` in a prompt. */
+export interface MentionExpansionResult {
+    /** The prompt with file contents prepended (or the original if no mentions). */
+    enrichedPrompt: string;
+    /**
+     * The prompt with each mention's `@` sigil removed but WITHOUT the attached
+     * block — i.e. `enrichedPrompt` minus its header. Callers that merge several
+     * expanders into one block need this: parsing the block back out of
+     * `enrichedPrompt` with a regex silently left the file bodies behind and
+     * attached every mentioned file twice.
+     */
+    strippedPrompt: string;
+    /** Successfully loaded files: `[fullPath, relativePath, content][]`. */
+    loaded: Array<{
+        fullPath: string;
+        relativePath: string;
+        content: string;
+    }>;
+    /** Mentions that couldn't be resolved, with a human-readable reason. */
+    failures: Array<{
+        mention: string;
+        reason: string;
+    }>;
+}
+/**
+ * The raw text of a mention match (without the leading `@`).
+ * Used internally by the tokenizer.
+ */
+interface MentionToken {
+    /** Full match including `@`, for replacement. */
+    raw: string;
+    /** The path portion (without quotes if it was quoted). */
+    path: string;
+    /** Start index in the source string. */
+    start: number;
+    /** End index (exclusive). */
+    end: number;
+}
+/**
+ * The single source of truth for "may a mention start after this character?".
+ * `MENTION_RE`'s lookbehind above and the editor's `detectMentionQuery` picker
+ * MUST agree — when they diverged, the picker happily completed mentions
+ * (e.g. after `]`) that the expander then ignored, so the file silently never
+ * got attached. Import this rather than re-spelling the class.
+ */
+export declare const MENTION_BOUNDARY: RegExp;
+/**
+ * Extract all `@-mention` tokens from `text`. Returns them in document
+ * order. Pure (no FS) — testable without touching the disk.
+ */
+export declare function extractMentions(text: string): MentionToken[];
+export interface MentionExpansionOptions {
+    /**
+     * The root directory mentions are resolved against when they're
+     * relative (not starting with `/` or `.`). Usually the project root
+     * or `process.cwd()`.
+     */
+    root: string;
+}
+/**
+ * Expand all `@-mentions` in `prompt`: load each referenced file,
+ * prepend the contents as an `[Attached files]` block, and strip the
+ * `@path` tokens from the visible prompt (replacing them with a bare
+ * path so the agent still sees what was referenced).
+ *
+ * Failures (missing file, too large, not a file) are collected and
+ * returned rather than thrown — the caller decides how to surface them.
+ */
+export declare function expandMentions(prompt: string, opts: MentionExpansionOptions): MentionExpansionResult;
+/**
+ * Max total bytes of file content we'll inline from a single `@folder`
+ * mention (200 KB). Prevents a huge directory from blowing the context
+ * window — the user can raise this via explicit `/add` if they really
+ * want everything.
+ */
+export declare const MAX_FOLDER_BYTES: number;
+/** One `@folder <path>` mention match. */
+interface FolderToken {
+    /** Full match including `@folder `, for display in failures. */
+    raw: string;
+    /** The path portion (after `@folder `). */
+    path: string;
+    /** Start index of the match (pointing at the `@`). */
+    start: number;
+    /** End index (exclusive). */
+    end: number;
+}
+/**
+ * Extract all `@folder`/`@dir` mentions from `text`. Pure (no FS).
+ * Returns them in document order.
+ */
+export declare function extractFolderMentions(text: string): FolderToken[];
+/**
+ * Expand all `@folder`/`@dir` mentions in `prompt`: recursively read
+ * every source file under each directory, and return them in the same
+ * shape as `expandMentions` (so the caller can merge the results).
+ *
+ * Skips the same ignored directories (`node_modules`, `.git`, …) and
+ * binary/generated extensions as the autocomplete scanner. Caps total
+ * content per mention at `MAX_FOLDER_BYTES` so a single huge tree
+ * can't blow the context window.
+ *
+ * Sync (filesystem reads only) — call before or after `expandMentions`.
+ */
+export declare function expandFolderMentions(prompt: string, opts: MentionExpansionOptions): MentionExpansionResult;
+/**
+ * Expand both `@folder` and `@file` mentions in one pass, merging the
+ * loaded files into a single `[Attached files]` block (instead of two
+ * separate blocks when called back-to-back).
+ *
+ * `@web` mentions are async and handled separately in `webFetch.ts`.
+ */
+export declare function expandFileAndFolderMentions(prompt: string, opts: MentionExpansionOptions): MentionExpansionResult;
+/** Format the `[Attached files]` block prepended to the enriched prompt. */
+export declare function formatFileBlock(files: Array<{
+    relativePath: string;
+    content: string;
+}>): string;
+export interface MentionSuggestion {
+    /** Display label for the picker (e.g. `src/index.ts`). */
+    label: string;
+    /** The path to insert after `@` when picked. */
+    insertPath: string;
+    /** A short hint — the file's directory or type. */
+    detail: string;
+}
+export interface SuggestOptions {
+    /** Root directory to scan. */
+    root: string;
+    /** Filter prefix typed so far (e.g. `src/ind` from `@src/ind`). */
+    query?: string;
+    /** Max suggestions to return. */
+    limit?: number;
+    /** Extra directories to skip (merged with the defaults). */
+    extraIgnoreDirs?: string[];
+}
+/**
+ * Build (or reuse from cache) the flat list of suggestible files under
+ * `root`, then filter by `query`. The scan walks up to `maxScan` files,
+ * skipping ignored directories and binary/generated extensions.
+ */
+export declare function suggestMentions(opts: SuggestOptions): MentionSuggestion[];
+/** Clear the suggestion cache. Call between tests so fixtures don't leak. */
+export declare function clearSuggestionCache(): void;
+/** True if `fullPath`'s basename looks like it holds secrets. */
+export declare function isSensitiveFile(fullPath: string): boolean;
+/** One `@git <ref>` mention match. */
+interface GitToken {
+    raw: string;
+    ref: string;
+    start: number;
+    end: number;
+}
+/**
+ * Extract all `@git <ref>` mentions from `text`. Pure (no FS / no git).
+ */
+export declare function extractGitMentions(text: string): GitToken[];
+/**
+ * Expand all `@git <ref>` mentions in `prompt`: resolve each ref to
+ * git content (diff, file-at-ref, or commit patch) and inject it as
+ * a `[Git ref]` block. Sync (git is run via `execSync`).
+ *
+ * The block is appended *after* any `[Attached files]` block from
+ * `@folder`/`@file` expansion, so the final prompt reads:
+ *
+ *   [Attached files] … [Git ref] … <user text>
+ */
+export declare function expandGitMentions(prompt: string, opts: MentionExpansionOptions): Promise<MentionExpansionResult>;
+export {};