mergestory 0.0.0-stage → 1.0.0

package/dist/analyzer/languages/rust.js

@@ -0,0 +1,164 @@
+// biome-ignore-all lint/suspicious/noAssignInExpressions: regex matches are assigned in the condition so the else-if chain stays flat
+/** Rust, with the routes of `#[get("/x")]` attributes and axum's `.route("/x", get(handler))`. */
+import { basename, dirname, joinPosix } from '../../core/posix.js';
+import { blockEnd, nestingDepths } from '../scan.js';
+import { C_COMMENTS, matchAll, packageRootOf, symbolEmitter } from './shared.js';
+const PROFILE = { lineComments: ['//'], blockComments: true, rustLifetimes: true };
+const PUB = '(pub(?:\\([^)]*\\))?\\s+)?';
+const RS_FN = new RegExp(`^${PUB}(?:(?:async|unsafe|const|default)\\s+|extern\\s+"[^"]*"\\s+)*fn\\s+(\\w+)`);
+const RS_ADT = new RegExp(`^${PUB}(struct|enum|trait|union)\\s+(\\w+)`);
+const RS_TYPE = new RegExp(`^${PUB}type\\s+(\\w+)`);
+const RS_CONST = new RegExp(`^${PUB}(?:const|static)\\s+(?:mut\\s+)?(\\w+)\\s*:`);
+const RS_ATTR_ROUTE = /^#\[(get|post|put|patch|delete|head|options)\(\s*"([^"]*)"/;
+const RS_AXUM = /\.route\(\s*"([^"]*)"\s*,\s*(get|post|put|patch|delete)\(/;
+/** Type name and trait-impl flag of an `impl` header line, or null when the line is not one. */
+function rustImpl(line) {
+    if (!/^impl\b/.test(line))
+        return null;
+    let head = line
+        .replace(/\{.*$/, '')
+        .replace(/^impl\b/, '')
+        .trim();
+    if (head.startsWith('<')) {
+        let depth = 0;
+        let end = 0;
+        for (let k = 0; k < head.length; k++) {
+            if (head[k] === '<')
+                depth++;
+            else if (head[k] === '>' && --depth === 0) {
+                end = k + 1;
+                break;
+            }
+        }
+        head = head.slice(end).trim();
+    }
+    const viaTrait = /\sfor\s/.test(head);
+    const typePart = viaTrait ? head.slice(head.search(/\sfor\s/) + 5) : head;
+    const type = /^[&\s]*(?:mut\s+)?([\w:]+)/.exec(typePart)?.[1];
+    return type ? { type: type.split('::').pop() ?? type, viaTrait } : null;
+}
+function detectRust(lines) {
+    const depths = nestingDepths(lines, PROFILE);
+    const { symbols, emit } = symbolEmitter(lines, depths);
+    let block = null;
+    let pending = null;
+    for (const [i, line] of lines.entries()) {
+        const t = line.trim();
+        if (!t || t.startsWith('//'))
+            continue;
+        const axum = RS_AXUM.exec(t);
+        if (axum) {
+            const [, path = '', verb = ''] = axum;
+            emit(`${verb.toUpperCase()} ${path}`, 'route', i);
+        }
+        if (block && i > block.end)
+            block = null;
+        const attr = RS_ATTR_ROUTE.exec(t);
+        if (attr) {
+            const [, verb = '', path = ''] = attr;
+            pending = `${verb.toUpperCase()} ${path}`;
+            continue;
+        }
+        let m;
+        if (depths[i] === 0) {
+            const impl = rustImpl(t);
+            if (impl) {
+                block = { ...impl, end: blockEnd(depths, i, lines.length), trait: false };
+                continue;
+            }
+            if ((m = RS_ADT.exec(t))) {
+                const [, pub, keyword = '', name = ''] = m;
+                const end = blockEnd(depths, i, lines.length);
+                const kind = keyword === 'trait' ? 'interface' : keyword === 'enum' ? 'type' : 'class';
+                emit(name, kind, i, { exported: !!pub, end });
+                if (keyword === 'trait')
+                    block = { type: name, viaTrait: false, end, trait: true };
+            }
+            else if ((m = RS_FN.exec(t))) {
+                const [, pub, name = ''] = m;
+                if (pending)
+                    emit(pending, 'route', i);
+                else
+                    emit(name, 'function', i, { exported: !!pub });
+                pending = null;
+            }
+            else if ((m = RS_TYPE.exec(t))) {
+                const [, pub, name = ''] = m;
+                emit(name, 'type', i, { exported: !!pub });
+            }
+            else if ((m = RS_CONST.exec(t))) {
+                const [, pub, name = ''] = m;
+                emit(name, 'constant', i, { exported: !!pub });
+            }
+        }
+        else if (block && depths[i] === 1 && (m = RS_FN.exec(t))) {
+            const [, pub, name = ''] = m;
+            if (pending)
+                emit(pending, 'route', i);
+            else
+                emit(`${block.type}.${name}`, 'method', i, { exported: !!pub || block.viaTrait || block.trait });
+            pending = null;
+        }
+    }
+    return symbols;
+}
+function extractImports(text) {
+    const refs = [];
+    for (const [, spec = ''] of matchAll(text, /^\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+(\w+)\s*;/gm)) {
+        refs.push({ lang: 'rs', spec, isMod: true });
+    }
+    for (const [, spec = ''] of matchAll(text, /^\s*(?:pub(?:\([^)]*\))?\s+)?use\s+([\w:]+)/gm)) {
+        refs.push({ lang: 'rs', spec, isMod: false });
+    }
+    return refs;
+}
+function resolveImport(importer, ref, index) {
+    const root = packageRootOf(importer);
+    const crateSrc = joinPosix(root, 'src');
+    const toFiles = (dir, parts) => {
+        const out = [];
+        for (let n = parts.length; n >= 1; n--) {
+            const base = joinPosix(dir, ...parts.slice(0, n));
+            out.push(`${base}.rs`, `${base}/mod.rs`);
+        }
+        return out;
+    };
+    const pick = (candidates, fallbackDir, name) => {
+        const hit = index.firstKnown(candidates);
+        if (hit)
+            return [hit];
+        return name ? [joinPosix(fallbackDir, `${name}.rs`)] : [];
+    };
+    if (ref.isMod) {
+        const name = basename(importer);
+        const dir = name === 'lib.rs' || name === 'main.rs' || name === 'mod.rs'
+            ? dirname(importer)
+            : joinPosix(dirname(importer), name.replace(/\.rs$/, ''));
+        return [index.firstKnown(toFiles(dir, [ref.spec])) ?? joinPosix(dir, `${ref.spec}.rs`)];
+    }
+    const parts = ref.spec.split('::').filter(Boolean);
+    const head = parts[0];
+    if (head === 'crate')
+        return pick(toFiles(crateSrc, parts.slice(1)), crateSrc, parts[1]);
+    if (head === 'super')
+        return pick(toFiles(dirname(dirname(importer)), parts.slice(1)), dirname(dirname(importer)), parts[1]);
+    if (head && index.known.size > 0) {
+        for (const p of index.known) {
+            const crate = /^(?:crates|packages|libs)\/([^/]+)\/Cargo\.toml$/.exec(p)?.[1];
+            if (crate?.replace(/-/g, '_') === head) {
+                const src = `${p.split('/').slice(0, 2).join('/')}/src`;
+                return pick(toFiles(src, parts.slice(1)), src, parts[1]);
+            }
+        }
+    }
+    return [];
+}
+const IMPORTS = {
+    lang: 'rs',
+    extract: extractImports,
+    resolve: resolveImport,
+};
+export const RUST = [
+    { extensions: ['.rs'], symbols: detectRust, imports: IMPORTS, comments: C_COMMENTS },
+];
+//# sourceMappingURL=rust.js.map

package/dist/analyzer/languages/shared.d.ts

@@ -0,0 +1,35 @@
+/** Helpers that the language modules share. */
+import type { SymbolKind } from '../../core/types.ts';
+import { type RawSymbol } from '../symbol-types.ts';
+/** What a full-line comment starts with, by syntax family. A line that starts with "*" continues a block. */
+export declare const C_COMMENTS: readonly ['//', '/*', '*'];
+export declare const HASH_COMMENTS: readonly ['#'];
+export declare const SQL_COMMENTS: readonly ['--'];
+export declare const MARKUP_COMMENTS: readonly ['<!--', '-->'];
+/** Every match of a global pattern in a text, counted from its start. */
+export declare function matchAll(text: string, pattern: RegExp): RegExpExecArray[];
+/** The package folder of a path in a monorepo ("packages/api" for "packages/api/src/a.ts"); "" elsewhere. */
+export declare function packageRootOf(path: string): string;
+export interface EmitOptions {
+    /** Whether other code can use the symbol. Default: true. */
+    exported?: boolean;
+    /**
+     * Last line, as a 0-based index. Default: the line where the bracket block that starts on the
+     * declaring line closes, or the declaring line itself when the detector tracks no brackets.
+     */
+    end?: number;
+    /** First line, as a 0-based index, when decorators or annotations come before the declaring line. */
+    start?: number;
+    /** The declaration text. Default: the declaring line up to its first "{". */
+    decl?: string;
+}
+export interface SymbolEmitter {
+    symbols: RawSymbol[];
+    /** Records a symbol. `line` is the 0-based index of the line that declares it. */
+    emit(name: string, kind: SymbolKind, line: number, options?: EmitOptions): void;
+}
+/**
+ * Collects the symbols that a detector finds. A detector that tracks brackets passes their depths
+ * (see `nestingDepths`), so that a symbol ends where its block closes.
+ */
+export declare function symbolEmitter(lines: readonly string[], depths?: readonly number[]): SymbolEmitter;

package/dist/analyzer/languages/shared.js

@@ -0,0 +1,43 @@
+import { blockEnd } from '../scan.js';
+import { signature } from '../symbol-types.js';
+/** What a full-line comment starts with, by syntax family. A line that starts with "*" continues a block. */
+export const C_COMMENTS = ['//', '/*', '*'];
+export const HASH_COMMENTS = ['#'];
+export const SQL_COMMENTS = ['--'];
+export const MARKUP_COMMENTS = ['<!--', '-->'];
+/** Every match of a global pattern in a text, counted from its start. */
+export function matchAll(text, pattern) {
+    pattern.lastIndex = 0;
+    return [...text.matchAll(pattern)];
+}
+const MONOREPO_PREFIXES = new Set(['packages', 'apps', 'services', 'libs', 'crates', 'modules', 'cmd']);
+/** The package folder of a path in a monorepo ("packages/api" for "packages/api/src/a.ts"); "" elsewhere. */
+export function packageRootOf(path) {
+    const [first, second] = path.split('/');
+    return first && second && MONOREPO_PREFIXES.has(first) && path.split('/').length > 2
+        ? `${first}/${second}`
+        : '';
+}
+/**
+ * Collects the symbols that a detector finds. A detector that tracks brackets passes their depths
+ * (see `nestingDepths`), so that a symbol ends where its block closes.
+ */
+export function symbolEmitter(lines, depths) {
+    const symbols = [];
+    return {
+        symbols,
+        emit(name, kind, line, options = {}) {
+            const { exported = true, start, end = depths ? blockEnd(depths, line, lines.length) : line, decl = signature(lines[line] ?? ''), } = options;
+            symbols.push({
+                name,
+                kind,
+                exported,
+                decl,
+                startLine: (start ?? line) + 1,
+                endLine: end + 1,
+                ...(start === undefined ? {} : { declLine: line + 1 }),
+            });
+        },
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/analyzer/languages/types.d.ts

@@ -0,0 +1,78 @@
+/** What the analyzer knows about a kind of file. Each language module fills in the parts that apply. */
+import type { RawSymbol } from '../symbol-types.ts';
+/** Finds the declarations of a file. `path` is for the languages whose rules depend on where a file is. */
+export type SymbolDetector = (lines: readonly string[], path: string) => RawSymbol[];
+/**
+ * One import statement, as the language writes it. `spec` is what the statement names: "./a",
+ * "com.acme.Foo", "crate::net".
+ */
+export type ImportRef = {
+    lang: 'js';
+    spec: string;
+} | {
+    lang: 'py';
+    spec: string;
+    dots: number;
+    names: string[];
+} | {
+    lang: 'go';
+    spec: string;
+} | {
+    lang: 'rs';
+    spec: string;
+    isMod: boolean;
+} | {
+    lang: 'jvm';
+    spec: string;
+} | {
+    lang: 'rb';
+    spec: string;
+} | {
+    lang: 'php';
+    spec: string;
+};
+export type ImportLang = ImportRef['lang'];
+/** What a resolver may ask about the repository. */
+export interface ImportIndex {
+    /** Every path known to exist at head: changed files plus the repository tree excerpt. */
+    readonly known: ReadonlySet<string>;
+    /** The known paths, by file name. */
+    readonly byBase: ReadonlyMap<string, readonly string[]>;
+    /** Go modules, longest module path first: the module path and the folder with go.mod ("" at the top). */
+    readonly goModules: readonly {
+        module: string;
+        dir: string;
+    }[];
+    /** Workspace package name (package.json "name") to its directory, in name order. */
+    readonly packageDirs: ReadonlyMap<string, string>;
+    /** The first candidate that is a known path once normalised, or null when none is. */
+    firstKnown(candidates: readonly string[]): string | null;
+}
+export interface ImportSupport<R extends ImportRef = ImportRef> {
+    /** The `lang` of the refs it makes. A ref is resolved by the support that has its `lang`. */
+    lang: R['lang'];
+    /** The imports in a file's text. Only statements that sit outside full-line comments count. */
+    extract(text: string): R[];
+    /** The repository paths an import names; none for an external or unknown target. */
+    resolve(importer: string, ref: R, index: ImportIndex): string[];
+}
+/** The import refs of one language. */
+export type ImportOf<L extends ImportLang> = Extract<ImportRef, {
+    lang: L;
+}>;
+export interface LanguageSupport {
+    /** Lower-case extensions with the dot. A file has the support of the one entry that lists its extension. */
+    extensions: readonly string[];
+    /** Lower-case names of files that have no extension, such as "makefile". */
+    names?: readonly string[];
+    /** Absent when the analyzer does not read declarations in the language. */
+    symbols?: SymbolDetector;
+    /** Absent when the analyzer does not read imports in the language. */
+    imports?: ImportSupport;
+    /** What a full-line comment starts with. Absent when the analyzer does not know the comment syntax. */
+    comments?: readonly string[];
+    /** Indentation carries meaning, so re-indenting is a real change. */
+    indentSensitive?: boolean;
+    /** Quote style, semicolons and trailing commas carry no meaning, so changing only those is formatting. */
+    looseSyntax?: boolean;
+}

package/dist/analyzer/languages/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/analyzer/pack-format.d.ts

@@ -0,0 +1,27 @@
+import type { DiffLine } from '../core/types.ts';
+export interface Masker {
+    /** Single-line text: secrets masked, line breaks collapsed. */
+    text(value: string): string;
+    /** Multi-line text: secrets masked, line breaks kept. */
+    block(value: string): string;
+    /** Mask one line of code. */
+    code(value: string): string;
+    /** Mask the lines of one hunk, including multi-line private keys. */
+    hunk(lines: readonly DiffLine[]): string[];
+}
+export declare function createMasker(maskMail: boolean): Masker;
+/** A Markdown fence longer than any backtick run inside, so untrusted text cannot close it early. */
+export declare function fence(body: string, info?: string): string;
+/** Make text safe for one Markdown table cell. */
+export declare function cell(value: string): string;
+/** Inline code span that survives backticks in the text. */
+export declare function code(value: string): string;
+export declare function numberedLine(number: number | null, marker: '+' | '-' | ' ', text: string): string;
+/** Collapse runs of consecutive ids with the same prefix: S1 S2 S3 -> "S1-S3". Other ids stay as they are. */
+export declare function compressIds(ids: readonly string[]): string;
+/**
+ * Collapse hunk ids: F2.H1 F2.H2 F2.H3 -> "F2.H1-H3", and a run of files that each have only H1
+ * -> "F5.H1-F9.H1" (H1 of every file from F5 to F9). Used only for very long lists. An id of another
+ * shape is kept as it is, after the collapsed ones.
+ */
+export declare function compressHunkIds(ids: readonly string[]): string;

package/dist/analyzer/pack-format.js

@@ -0,0 +1,139 @@
+/** Formatting and masking helpers for the evidence pack. */
+import { MASK_CHAR, maskPrivate } from '../core/secrets.js';
+import { truncate } from '../core/text.js';
+const MASK = MASK_CHAR.repeat(8);
+const KEY_BEGIN = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/;
+const KEY_END = /-----END [A-Z0-9 ]*PRIVATE KEY-----/;
+const BASE64_BODY = /^[A-Za-z0-9+/=]{48,}$/;
+const MAX_CODE_LINE = 240;
+export function createMasker(maskMail) {
+    const block = (value) => maskPrivate(value, { maskEmails: maskMail });
+    const text = (value) => block(value).replace(/[\r\n\u2028\u2029]+/g, ' ');
+    const code = (value) => truncate(text(value.replace(/\t/g, '  ')), MAX_CODE_LINE);
+    return {
+        text,
+        block,
+        code,
+        hunk(lines) {
+            let inKey = false;
+            return lines.map((line) => {
+                const t = line.text;
+                if (KEY_BEGIN.test(t)) {
+                    inKey = !KEY_END.test(t);
+                    return MASK;
+                }
+                if (inKey) {
+                    if (KEY_END.test(t))
+                        inKey = false;
+                    return MASK;
+                }
+                if (BASE64_BODY.test(t.trim()))
+                    return MASK;
+                return code(t);
+            });
+        },
+    };
+}
+/** A Markdown fence longer than any backtick run inside, so untrusted text cannot close it early. */
+export function fence(body, info = '') {
+    let longest = 0;
+    for (const m of body.matchAll(/`+/g))
+        longest = Math.max(longest, m[0].length);
+    const marks = '`'.repeat(Math.max(3, longest + 1));
+    return `${marks}${info}\n${body}\n${marks}`;
+}
+/** Make text safe for one Markdown table cell. */
+export function cell(value) {
+    return value
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/\|/g, '\\|')
+        .replace(/`/g, "'");
+}
+/** Inline code span that survives backticks in the text. */
+export function code(value) {
+    return `\`${value.replace(/[\r\n`]+/g, ' ')}\``;
+}
+export function numberedLine(number, marker, text) {
+    return `${String(number ?? '').padStart(4)} ${marker} ${text}`;
+}
+const SIMPLE_ID = /^([A-Z]+)(\d+)$/;
+/** Collapse runs of consecutive ids with the same prefix: S1 S2 S3 -> "S1-S3". Other ids stay as they are. */
+export function compressIds(ids) {
+    const parts = [];
+    let i = 0;
+    while (i < ids.length) {
+        const first = SIMPLE_ID.exec(ids[i]);
+        if (!first) {
+            parts.push(ids[i]);
+            i++;
+            continue;
+        }
+        let j = i;
+        let last = Number(first[2]);
+        while (j + 1 < ids.length) {
+            const next = SIMPLE_ID.exec(ids[j + 1]);
+            if (!next || next[1] !== first[1] || Number(next[2]) !== last + 1)
+                break;
+            last = Number(next[2]);
+            j++;
+        }
+        parts.push(j > i ? `${first[1]}${first[2]}-${first[1]}${last}` : ids[i]);
+        i = j + 1;
+    }
+    return parts.join(', ');
+}
+/**
+ * Collapse hunk ids: F2.H1 F2.H2 F2.H3 -> "F2.H1-H3", and a run of files that each have only H1
+ * -> "F5.H1-F9.H1" (H1 of every file from F5 to F9). Used only for very long lists. An id of another
+ * shape is kept as it is, after the collapsed ones.
+ */
+export function compressHunkIds(ids) {
+    const byFile = new Map();
+    const others = [];
+    for (const id of ids) {
+        const m = /^F(\d+)\.H(\d+)$/.exec(id);
+        if (!m) {
+            others.push(id);
+            continue;
+        }
+        const file = Number(m[1]);
+        byFile.set(file, [...(byFile.get(file) ?? []), Number(m[2])]);
+    }
+    const parts = [];
+    let run = [];
+    const flushRun = () => {
+        if (run.length === 1)
+            parts.push(`F${run[0]}.H1`);
+        else if (run.length > 1)
+            parts.push(`F${run[0]}.H1-F${run[run.length - 1]}.H1`);
+        run = [];
+    };
+    for (const [file, hunks] of byFile) {
+        hunks.sort((a, b) => a - b);
+        if (hunks.length === 1 && hunks[0] === 1) {
+            if (run.length > 0 && run[run.length - 1] + 1 !== file)
+                flushRun();
+            run.push(file);
+            continue;
+        }
+        flushRun();
+        let start = hunks[0];
+        let prev = start;
+        const emit = () => {
+            parts.push(start === prev ? `F${file}.H${start}` : `F${file}.H${start}-H${prev}`);
+        };
+        for (const n of hunks.slice(1)) {
+            if (n === prev + 1)
+                prev = n;
+            else {
+                emit();
+                start = n;
+                prev = n;
+            }
+        }
+        emit();
+    }
+    flushRun();
+    return [...parts, ...others].join(', ');
+}
+//# sourceMappingURL=pack-format.js.map

package/dist/analyzer/pack.d.ts

@@ -0,0 +1,26 @@
+import type { Analysis, ChangeSet, ContextInputs } from '../core/types.ts';
+export interface EvidencePackOptions {
+    /** Approximate token budget for the whole pack. */
+    maxTokens: number;
+    /** "minimal" leaves out all code lines (metadata, paths and symbol names only). */
+    llmContext: 'full' | 'minimal';
+    targetDurationSec: number;
+    style: 'technical' | 'product' | 'hybrid';
+    language: string;
+    /** Mask e-mail addresses in the pack. Default true. */
+    maskEmails?: boolean;
+}
+export interface EvidencePack {
+    /** Markdown document: the LLM prompt body and the agent-facing evidence.md. */
+    markdown: string;
+    approxTokens: number;
+    /** Hunk ids whose code is included. */
+    includedHunks: string[];
+    /** Hunk ids left out to stay within the budget. */
+    omittedHunks: string[];
+}
+/**
+ * Build the evidence pack. It stays within `options.maxTokens` by shrinking the fixed sections
+ * and then including key hunks in score order; hunks that do not fit are listed by id.
+ */
+export declare function buildEvidencePack(changeSet: ChangeSet, analysis: Analysis, inputs: ContextInputs, options: EvidencePackOptions): EvidencePack;