mergestory 0.0.0-stage → 1.0.0

package/dist/analyzer/dependencies.js

@@ -0,0 +1,349 @@
+/** Dependency changes read from manifest files at base and head. */
+import { basename } from '../core/posix.js';
+/** A requirements file for development: the file name says so, or it sits in a requirements/ folder. */
+const DEV_REQUIREMENTS = /(?:^|\/)requirements[-_.]?(?:dev|test)[^/]*\.txt$|(?:^|\/)requirements\/(?:dev|test)[^/]*$/i;
+const MANIFEST_KINDS = {
+    'package.json': {
+        ecosystem: 'npm',
+        parse: (c) => parsePackageJson(c, [
+            ['dependencies', false],
+            ['optionalDependencies', false],
+            ['peerDependencies', false],
+            ['devDependencies', true],
+        ]),
+    },
+    composer: {
+        ecosystem: 'other',
+        parse: (c) => parsePackageJson(c, [
+            ['require', false],
+            ['require-dev', true],
+        ]),
+    },
+    requirements: { ecosystem: 'pypi', parse: (c, p) => parseRequirements(c, DEV_REQUIREMENTS.test(p)) },
+    'go.mod': { ecosystem: 'go', parse: parseGoMod },
+    cargo: { ecosystem: 'cargo', parse: parseCargo },
+    pyproject: { ecosystem: 'pypi', parse: parsePyproject },
+    pipfile: { ecosystem: 'pypi', parse: parsePipfile },
+    gemfile: { ecosystem: 'rubygems', parse: parseGemfile },
+    pom: { ecosystem: 'maven', parse: parsePom },
+};
+export function manifestKind(path) {
+    const name = basename(path).toLowerCase();
+    if (name === 'package.json')
+        return 'package.json';
+    if (name === 'composer.json')
+        return 'composer';
+    if (/^requirements([-_.][\w.-]+)?\.txt$/.test(name) || /(^|\/)requirements\/[^/]+\.txt$/.test(path))
+        return 'requirements';
+    if (name === 'go.mod')
+        return 'go.mod';
+    if (name === 'cargo.toml')
+        return 'cargo';
+    if (name === 'pyproject.toml')
+        return 'pyproject';
+    if (name === 'pipfile')
+        return 'pipfile';
+    if (name === 'gemfile')
+        return 'gemfile';
+    if (name === 'pom.xml')
+        return 'pom';
+    return null;
+}
+function parsePackageJson(content, sections) {
+    let json;
+    try {
+        json = JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+    if (!json || typeof json !== 'object')
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const [section, dev] of sections) {
+        const table = json[section];
+        if (!table || typeof table !== 'object')
+            continue;
+        for (const [name, version] of Object.entries(table)) {
+            if (typeof version !== 'string' || name === 'php' || name.startsWith('ext-'))
+                continue;
+            const key = `${dev ? 'dev' : 'prod'}:${name}`;
+            if (seen.has(key) || (!dev && seen.has(`prod:${name}`)))
+                continue;
+            seen.add(key);
+            out.push({ name, version, dev });
+        }
+    }
+    return out;
+}
+const REQUIREMENT = /^([A-Za-z0-9][A-Za-z0-9._-]*)(?:\[[^\]]*\])?\s*([<>=!~][^;#]*)?/;
+function requirementEntry(text, dev) {
+    const m = REQUIREMENT.exec(text.trim());
+    if (!m)
+        return null;
+    const spec = (m[2] ?? '').replace(/\s+/g, '');
+    return {
+        name: m[1].toLowerCase().replace(/_/g, '-'),
+        version: spec.replace(/^==/, '') || '*',
+        dev,
+    };
+}
+function parseRequirements(content, dev) {
+    const out = [];
+    for (const raw of content.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#') || line.startsWith('-') || /^(git\+|https?:|\.|\/)/.test(line))
+            continue;
+        const entry = requirementEntry(line, dev);
+        if (entry)
+            out.push(entry);
+    }
+    return out;
+}
+function parseGoMod(content) {
+    const out = [];
+    let inBlock = false;
+    for (const raw of content.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (/^require\s*\($/.test(line)) {
+            inBlock = true;
+            continue;
+        }
+        if (inBlock && line === ')') {
+            inBlock = false;
+            continue;
+        }
+        const single = /^require\s+(\S+)\s+(\S+)(.*)$/.exec(line);
+        const block = inBlock ? /^(\S+)\s+(v\S+)(.*)$/.exec(line) : null;
+        const m = single ?? block;
+        if (m && !/\/\/\s*indirect/.test(m[3]))
+            out.push({ name: m[1], version: m[2], dev: false });
+    }
+    return out;
+}
+function stripTomlComment(line) {
+    let quote = '';
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (quote) {
+            if (ch === '\\' && quote === '"')
+                i++;
+            else if (ch === quote)
+                quote = '';
+        }
+        else if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === '#')
+            return line.slice(0, i);
+    }
+    return line;
+}
+function bracketBalance(text) {
+    let depth = 0;
+    let quote = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (quote) {
+            if (ch === '\\' && quote === '"')
+                i++;
+            else if (ch === quote)
+                quote = '';
+        }
+        else if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === '[' || ch === '{')
+            depth++;
+        else if (ch === ']' || ch === '}')
+            depth--;
+    }
+    return depth;
+}
+function scanToml(content) {
+    const items = [];
+    const lines = content.split(/\r?\n/);
+    let table = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = stripTomlComment(lines[i]).trim();
+        if (!line)
+            continue;
+        const header = /^\[\[?\s*([^\]]+?)\s*\]\]?$/.exec(line);
+        if (header) {
+            table = header[1].replace(/\s+/g, '').replace(/["']/g, '');
+            continue;
+        }
+        const kv = /^([A-Za-z0-9_."'-]+)\s*=\s*(.*)$/.exec(line);
+        if (!kv)
+            continue;
+        let value = kv[2];
+        while (bracketBalance(value) > 0 && i + 1 < lines.length) {
+            i++;
+            value += ` ${stripTomlComment(lines[i]).trim()}`;
+        }
+        items.push({ table, key: kv[1].replace(/["']/g, ''), value: value.trim() });
+    }
+    return items;
+}
+function tomlVersion(value) {
+    const plain = /^["']([^"']*)["']$/.exec(value);
+    if (plain)
+        return plain[1] || '*';
+    const v = /\bversion\s*=\s*["']([^"']*)["']/.exec(value);
+    if (v)
+        return v[1];
+    if (/\bworkspace\s*=\s*true/.test(value))
+        return 'workspace';
+    if (/\bpath\s*=/.test(value))
+        return 'path';
+    if (/\bgit\s*=/.test(value))
+        return 'git';
+    return '*';
+}
+function parseCargo(content) {
+    const out = [];
+    for (const { table, key, value } of scanToml(content)) {
+        const dev = /dev-dependencies/.test(table);
+        if (/(^|\.)(dev-|build-)?dependencies$/.test(table)) {
+            const dotted = /^([^.]+)\.workspace$/.exec(key);
+            if (dotted)
+                out.push({ name: dotted[1], version: 'workspace', dev });
+            else
+                out.push({ name: key, version: tomlVersion(value), dev });
+        }
+        else {
+            const sub = /^(?:.*\.)?(dev-|build-)?dependencies\.([^.]+)$/.exec(table);
+            if (sub && key === 'version')
+                out.push({ name: sub[2], version: tomlVersion(value), dev: sub[1] === 'dev-' });
+        }
+    }
+    return out;
+}
+function arrayEntries(value, dev) {
+    const out = [];
+    for (const m of value.matchAll(/["']([^"']+)["']/g)) {
+        const entry = requirementEntry(m[1], dev);
+        if (entry)
+            out.push(entry);
+    }
+    return out;
+}
+function parsePyproject(content) {
+    const out = [];
+    for (const { table, key, value } of scanToml(content)) {
+        if (table === 'project' && key === 'dependencies')
+            out.push(...arrayEntries(value, false));
+        else if (table === 'project.optional-dependencies')
+            out.push(...arrayEntries(value, /dev|test|lint|doc|type/i.test(key)));
+        else if (table === 'dependency-groups')
+            out.push(...arrayEntries(value, true));
+        else if (table === 'tool.uv' && key === 'dev-dependencies')
+            out.push(...arrayEntries(value, true));
+        else if (/^tool\.poetry\.(dependencies|dev-dependencies|group\.[^.]+\.dependencies)$/.test(table) &&
+            key !== 'python') {
+            out.push({
+                name: key.toLowerCase().replace(/_/g, '-'),
+                version: tomlVersion(value),
+                dev: !/^tool\.poetry\.dependencies$/.test(table),
+            });
+        }
+    }
+    return out;
+}
+function parsePipfile(content) {
+    const out = [];
+    for (const { table, key, value } of scanToml(content)) {
+        if (table === 'packages' || table === 'dev-packages') {
+            out.push({
+                name: key.toLowerCase().replace(/_/g, '-'),
+                version: tomlVersion(value).replace(/^==/, ''),
+                dev: table === 'dev-packages',
+            });
+        }
+    }
+    return out;
+}
+function parseGemfile(content) {
+    const out = [];
+    const groups = [];
+    for (const raw of content.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (/^group\b.*\bdo\b/.test(line)) {
+            groups.push(/:(development|test)\b/.test(line));
+            continue;
+        }
+        if (/^end\b/.test(line) && groups.length > 0) {
+            groups.pop();
+            continue;
+        }
+        const gem = /^gem\s+['"]([^'"]+)['"](?:\s*,\s*['"]([^'"]+)['"])?/.exec(line);
+        if (gem)
+            out.push({ name: gem[1], version: gem[2] ?? '*', dev: groups.some(Boolean) });
+    }
+    return out;
+}
+function parsePom(content) {
+    const out = [];
+    for (const block of content.matchAll(/<dependency>([\s\S]*?)<\/dependency>/g)) {
+        const text = block[1];
+        const tag = (name) => new RegExp(`<${name}>\\s*([^<]*?)\\s*</${name}>`).exec(text)?.[1] ?? null;
+        const group = tag('groupId');
+        const artifact = tag('artifactId');
+        if (!group || !artifact)
+            continue;
+        out.push({ name: `${group}:${artifact}`, version: tag('version') ?? '*', dev: tag('scope') === 'test' });
+    }
+    return out;
+}
+/** Dependency changes in one manifest file. `base` and `head` are file contents (null when absent). */
+export function diffManifest(file, base, head) {
+    const kind = manifestKind(file.path);
+    if (!kind)
+        return [];
+    const { ecosystem, parse } = MANIFEST_KINDS[kind];
+    const toMap = (content, path) => {
+        const map = new Map();
+        if (content === null)
+            return map;
+        for (const e of parse(content, path))
+            if (!map.has(`${e.dev ? 'dev' : 'prod'}:${e.name}`))
+                map.set(`${e.dev ? 'dev' : 'prod'}:${e.name}`, e);
+        return map;
+    };
+    const before = toMap(base, file.oldPath ?? file.path);
+    const after = toMap(head, file.path);
+    const out = [];
+    const make = (change, entry, from, to) => ({
+        ecosystem,
+        name: entry.name,
+        change,
+        from,
+        to,
+        dev: entry.dev,
+        fileId: file.id,
+    });
+    for (const [key, h] of after) {
+        const b = before.get(key);
+        if (!b)
+            out.push(make('added', h, null, h.version));
+        else if (b.version !== h.version)
+            out.push(make('updated', h, b.version, h.version));
+    }
+    for (const [key, b] of before)
+        if (!after.has(key))
+            out.push(make('removed', b, b.version, null));
+    // A dependency that moved between dev and prod with the same version is not a change.
+    const moved = new Set();
+    for (const a of out) {
+        if (a.change !== 'added')
+            continue;
+        const r = out.find((x) => x.change === 'removed' && x.name === a.name && x.from === a.to && x.dev !== a.dev);
+        if (r) {
+            moved.add(`added:${a.name}:${a.dev}`);
+            moved.add(`removed:${r.name}:${r.dev}`);
+        }
+    }
+    return out
+        .filter((c) => !moved.has(`${c.change}:${c.name}:${c.dev}`))
+        .sort((a, b) => a.name.localeCompare(b.name) || a.change.localeCompare(b.change));
+}
+//# sourceMappingURL=dependencies.js.map

package/dist/analyzer/evidence.d.ts

@@ -0,0 +1,15 @@
+/** The evidence index: every citable fact, with a short label and a link when one exists. */
+import type { ChangeSet, Component, ContextInputs, DependencyChange, EvidenceItem, RiskSignal, SymbolChange } from '../core/types.ts';
+/** Mask secrets and e-mail addresses in text that ends up in a label. */
+export declare function cleanLabel(text: string, max: number): string;
+export interface EvidenceSources {
+    changeSet: ChangeSet;
+    inputs: ContextInputs;
+    /** File ids whose content is hidden: they get a file item but no hunk items. */
+    hiddenFileIds: ReadonlySet<string>;
+    components: readonly Component[];
+    symbols: readonly SymbolChange[];
+    risks: readonly RiskSignal[];
+    dependencies: readonly DependencyChange[];
+}
+export declare function buildEvidenceIndex(src: EvidenceSources): EvidenceItem[];

package/dist/analyzer/evidence.js

@@ -0,0 +1,73 @@
+/** The evidence index: every citable fact, with a short label and a link when one exists. */
+import { maskPrivate } from '../core/secrets.js';
+import { truncate } from '../core/text.js';
+import { hunkPath, hunkRange } from './hunks.js';
+import { blobUrl, shortSha } from './util.js';
+/** Mask secrets and e-mail addresses in text that ends up in a label. */
+export function cleanLabel(text, max) {
+    // Labels always mask e-mail addresses, whatever the privacy setting.
+    return truncate(maskPrivate(text.replace(/\s+/g, ' ').trim(), { maskEmails: true }), max);
+}
+export function buildEvidenceIndex(src) {
+    const { changeSet, inputs } = src;
+    const web = changeSet.repo.webUrl;
+    const headSha = changeSet.head.sha;
+    const baseSha = changeSet.base.sha;
+    const urlFor = (ref) => blobUrl(web, ref.side === 'head' ? headSha : baseSha, ref.path, ref.startLine, ref.endLine);
+    const items = [];
+    const add = (id, kind, label, ref, url) => {
+        items.push({ id, kind, label, ref, url });
+    };
+    if (changeSet.pr)
+        add('PR', 'pr', 'PR description', null, changeSet.pr.url || null);
+    if (inputs.task?.trim())
+        add('TASK', 'task', 'Task description', null, null);
+    if (inputs.notes?.trim())
+        add('NOTES', 'notes', 'Implementation notes', null, null);
+    for (const t of inputs.tests) {
+        add(t.id, 'test', `Test run: ${cleanLabel(t.command, 60)} (${t.passed ? 'passed' : 'failed'}, reported by the caller)`, null, null);
+    }
+    for (const issue of changeSet.linkedIssues) {
+        add(issue.id, 'issue', `Issue #${issue.number}: ${cleanLabel(issue.title, 60)}`, null, issue.url || null);
+    }
+    for (const c of changeSet.commits) {
+        const url = web ? `${web.replace(/\/+$/, '')}/commit/${c.sha}` : null;
+        add(c.id, 'commit', `Commit ${shortSha(c.sha)}: ${cleanLabel(c.subject, 70)}`, null, url);
+    }
+    for (const file of changeSet.files) {
+        const side = file.status === 'deleted' ? 'base' : 'head';
+        add(file.id, 'file', cleanLabel(file.path, 120), null, blobUrl(web, side === 'head' ? headSha : baseSha, file.path));
+        if (src.hiddenFileIds.has(file.id))
+            continue;
+        for (const hunk of file.hunks) {
+            const range = hunkRange(hunk);
+            const path = hunkPath(file, range);
+            const ref = { path, ...range };
+            add(hunk.id, 'hunk', `${cleanLabel(path, 100)}:${range.startLine}-${range.endLine}`, ref, urlFor(ref));
+        }
+    }
+    for (const s of src.symbols) {
+        const ref = { path: s.path, side: s.side, startLine: s.startLine, endLine: s.endLine };
+        add(s.id, 'symbol', `${cleanLabel(s.name, 80)} (${cleanLabel(s.path, 80)}:${s.startLine}-${s.endLine})`, ref, urlFor(ref));
+    }
+    for (const m of src.components) {
+        const url = web && m.path !== '.'
+            ? `${web.replace(/\/+$/, '')}/tree/${headSha}/${m.path.split('/').map(encodeURIComponent).join('/')}`
+            : null;
+        add(m.id, 'component', `${cleanLabel(m.name, 60)} (${cleanLabel(m.path, 80)})`, null, m.status === 'removed' ? null : url);
+    }
+    for (const r of src.risks)
+        add(r.id, 'risk', cleanLabel(r.title, 100), r.ref, r.ref ? urlFor(r.ref) : null);
+    const fileById = new Map(changeSet.files.map((f) => [f.id, f]));
+    for (const d of src.dependencies) {
+        const file = fileById.get(d.fileId);
+        const detail = d.change === 'removed' ? 'removed' : `${d.change} ${d.to ?? ''}`.trim();
+        const url = file ? blobUrl(web, file.status === 'deleted' ? baseSha : headSha, file.path) : null;
+        add(d.id, 'dependency', `${cleanLabel(d.name, 80)} (${detail})`, null, url);
+    }
+    for (const s of inputs.screenshots)
+        add(s.id, 'screenshot', cleanLabel(s.caption || `Screenshot (${s.moment})`, 100), null, null);
+    add('REPO', 'repo', 'Repository structure', null, web);
+    return items;
+}
+//# sourceMappingURL=evidence.js.map

package/dist/analyzer/hunks.d.ts

@@ -0,0 +1,21 @@
+/** Hunk ranges and key-hunk ranking. */
+import type { ChangedFile, DiffHunk, FileRole, KeyHunk, RiskSignal, Side, SymbolChange } from '../core/types.ts';
+export declare const MAX_KEY_HUNKS = 12;
+export interface HunkRange {
+    side: Side;
+    startLine: number;
+    endLine: number;
+}
+/** The lines a hunk covers: head side unless the hunk only deletes. */
+export declare function hunkRange(hunk: DiffHunk): HunkRange;
+/** The path a hunk is read at: a hunk that only removes lines is read at base, where a renamed file still has its old path. */
+export declare function hunkPath(file: ChangedFile, range: HunkRange): string;
+export declare function changedLineCount(hunk: DiffHunk): number;
+export interface RankFile {
+    file: ChangedFile;
+    role: FileRole;
+    trivial: boolean;
+    hidden: boolean;
+}
+/** Score hunks by size, role and bonuses, and keep the best ones. */
+export declare function rankKeyHunks(files: readonly RankFile[], symbols: readonly SymbolChange[], risks: readonly RiskSignal[]): KeyHunk[];

package/dist/analyzer/hunks.js

@@ -0,0 +1,88 @@
+import { ROLE_WEIGHT } from './roles.js';
+import { commentOnlyHunk } from './trivial.js';
+import { round } from './util.js';
+export const MAX_KEY_HUNKS = 12;
+/** The lines a hunk covers: head side unless the hunk only deletes. */
+export function hunkRange(hunk) {
+    const hasAdd = hunk.lines.some((l) => l.kind === 'add');
+    if (hasAdd || hunk.oldLines === 0) {
+        const start = Math.max(1, hunk.newStart);
+        return { side: 'head', startLine: start, endLine: Math.max(start, hunk.newStart + hunk.newLines - 1) };
+    }
+    const start = Math.max(1, hunk.oldStart);
+    return { side: 'base', startLine: start, endLine: Math.max(start, hunk.oldStart + hunk.oldLines - 1) };
+}
+/** The path a hunk is read at: a hunk that only removes lines is read at base, where a renamed file still has its old path. */
+export function hunkPath(file, range) {
+    return range.side === 'base' && file.oldPath ? file.oldPath : file.path;
+}
+export function changedLineCount(hunk) {
+    let n = 0;
+    for (const l of hunk.lines)
+        if (l.kind !== 'ctx')
+            n++;
+    return n;
+}
+/** Score hunks by size, role and bonuses, and keep the best ones. */
+export function rankKeyHunks(files, symbols, risks) {
+    const out = [];
+    let order = 0;
+    for (const { file, role, trivial, hidden } of files) {
+        if (hidden || trivial || file.binary)
+            continue;
+        const weight = ROLE_WEIGHT[role];
+        if (weight <= 0)
+            continue;
+        for (const hunk of file.hunks) {
+            order++;
+            const changed = changedLineCount(hunk);
+            if (changed === 0)
+                continue;
+            const range = hunkRange(hunk);
+            const reasons = [`${changed} changed ${changed === 1 ? 'line' : 'lines'}`];
+            let score = (Math.log1p(changed) / Math.log1p(30)) * weight;
+            if (role !== 'source')
+                reasons.push(`${role} file`);
+            if (commentOnlyHunk(file.path, hunk)) {
+                score *= 0.3;
+                reasons.push('comment-only');
+            }
+            const newExport = symbols.find((s) => s.fileId === file.id &&
+                s.exported &&
+                s.change === 'added' &&
+                s.side === 'head' &&
+                range.side === 'head' &&
+                s.startLine <= range.endLine &&
+                s.endLine >= range.startLine);
+            if (newExport) {
+                score += 0.35;
+                reasons.push(`new exported ${newExport.kind} ${newExport.name}`);
+            }
+            const flagged = risks.filter((r) => r.evidence.includes(hunk.id));
+            if (flagged.length > 0) {
+                score += flagged.some((r) => r.severity === 'high') ? 0.4 : 0.3;
+                reasons.push(`risk ${flagged.map((r) => r.id).join(', ')}`);
+            }
+            if (file.status === 'added') {
+                score += 0.2;
+                reasons.push('new file');
+            }
+            out.push({
+                id: hunk.id,
+                fileId: file.id,
+                path: hunkPath(file, range),
+                side: range.side,
+                startLine: range.startLine,
+                endLine: range.endLine,
+                score: round(score),
+                reasons,
+                order,
+            });
+        }
+    }
+    return out
+        .sort((a, b) => b.score - a.score || a.order - b.order)
+        .slice(0, MAX_KEY_HUNKS)
+        .map(({ order: _order, ...hunk }) => hunk);
+}
+//# sourceMappingURL=hunks.js.map

package/dist/analyzer/imports.d.ts

@@ -0,0 +1,46 @@
+import type { ImportIndex, ImportLang, ImportRef } from './languages/types.ts';
+/** The language of the imports in a file, or null when the analyzer does not read them. */
+export declare function importLang(path: string): ImportLang | null;
+/** Raw import references found in a file. Only statements that sit outside full-line comments count. */
+export declare function extractImports(path: string, content: string): ImportRef[];
+export interface ResolverOptions {
+    /** Every path known to exist at head: changed files plus the repository tree excerpt. */
+    knownPaths: Iterable<string>;
+    /** Go modules: module path and the directory holding go.mod ("" for the repository root). */
+    goModules?: {
+        module: string;
+        dir: string;
+    }[];
+    /** Workspace package name (package.json "name") to its directory. */
+    packageDirs?: Map<string, string>;
+}
+/** Resolves import references to repository paths, through the language that made them. */
+export declare class ImportResolver implements ImportIndex {
+    readonly known: ReadonlySet<string>;
+    readonly byBase: Map<string, string[]>;
+    readonly goModules: readonly {
+        module: string;
+        dir: string;
+    }[];
+    readonly packageDirs: ReadonlyMap<string, string>;
+    constructor(options: ResolverOptions);
+    firstKnown(candidates: readonly string[]): string | null;
+    resolve(importer: string, ref: ImportRef): string[];
+}
+export interface ResolverOptionsInput {
+    /** Directories of the components of the change; the workspace ones among them are looked at. */
+    componentPaths: readonly string[];
+    /** Which manifests are worth reading: package.json for "js", go.mod for "go". */
+    languages: ReadonlySet<ImportLang>;
+    /** A workspace manifest need not be part of the change, so no changed file carries a verdict for it: this decides whether it is asked for at all. */
+    isExcluded: (path: string) => boolean;
+    /** Reads a file at head; null when it does not exist. */
+    readHead: (path: string) => Promise<string | null>;
+    concurrency: number;
+}
+/**
+ * Workspace package names and Go modules, read from the manifests of the workspace directories.
+ * The results follow the order of the directories, so the same change always resolves the same way;
+ * when two workspaces share a package name, the first one keeps it.
+ */
+export declare function loadResolverOptions(input: ResolverOptionsInput): Promise<Required<Pick<ResolverOptions, 'goModules' | 'packageDirs'>>>;

package/dist/analyzer/imports.js

@@ -0,0 +1,87 @@
+/** Import statement parsing and resolution, used to draw component-to-component relationships. */
+import { mapLimit } from '../core/concurrency.js';
+import { basename, normalizePosix } from '../core/posix.js';
+import { importSupport, languageSupport } from './languages/index.js';
+const MAX_PARSE_CHARS = 400_000;
+const MAX_WORKSPACE_READS = 12;
+const WORKSPACE_DIR = /^(packages|apps|services|libs|modules|cmd|crates)\/[^/]+$/;
+/** The language of the imports in a file, or null when the analyzer does not read them. */
+export function importLang(path) {
+    return languageSupport(path)?.imports?.lang ?? null;
+}
+/** Raw import references found in a file. Only statements that sit outside full-line comments count. */
+export function extractImports(path, content) {
+    const imports = languageSupport(path)?.imports;
+    if (!imports)
+        return [];
+    return imports.extract(content.length > MAX_PARSE_CHARS ? content.slice(0, MAX_PARSE_CHARS) : content);
+}
+/** Resolves import references to repository paths, through the language that made them. */
+export class ImportResolver {
+    known;
+    byBase = new Map();
+    goModules;
+    packageDirs;
+    constructor(options) {
+        this.known = new Set(options.knownPaths);
+        // Longest module path first, so the most specific module wins whatever order they were found in.
+        this.goModules = [...(options.goModules ?? [])].sort((a, b) => b.module.length - a.module.length || a.module.localeCompare(b.module));
+        this.packageDirs = new Map([...(options.packageDirs ?? new Map())].sort(([a], [b]) => a.localeCompare(b)));
+        for (const p of this.known) {
+            const b = basename(p);
+            this.byBase.set(b, [...(this.byBase.get(b) ?? []), p]);
+        }
+    }
+    firstKnown(candidates) {
+        for (const c of candidates) {
+            const n = normalizePosix(c);
+            if (n !== null && this.known.has(n))
+                return n;
+        }
+        return null;
+    }
+    resolve(importer, ref) {
+        return importSupport(ref.lang)?.resolve(importer, ref, this) ?? [];
+    }
+}
+/**
+ * Workspace package names and Go modules, read from the manifests of the workspace directories.
+ * The results follow the order of the directories, so the same change always resolves the same way;
+ * when two workspaces share a package name, the first one keeps it.
+ */
+export async function loadResolverOptions(input) {
+    const { readHead, concurrency } = input;
+    const dirs = input.componentPaths
+        .filter((p) => WORKSPACE_DIR.test(p))
+        .filter((p) => !input.isExcluded(`${p}/package.json`) && !input.isExcluded(`${p}/go.mod`))
+        .slice(0, MAX_WORKSPACE_READS);
+    const [names, modules] = await Promise.all([
+        input.languages.has('js')
+            ? mapLimit(dirs, concurrency, async (dir) => {
+                const text = await readHead(`${dir}/package.json`);
+                try {
+                    const name = JSON.parse(text ?? 'null')?.name;
+                    return typeof name === 'string' && name ? name : null;
+                }
+                catch {
+                    return null; // not JSON: ignore
+                }
+            })
+            : [],
+        input.languages.has('go')
+            ? mapLimit(['', ...dirs], concurrency, async (dir) => {
+                const text = await readHead(dir ? `${dir}/go.mod` : 'go.mod');
+                return text ? (/^module\s+(\S+)/m.exec(text)?.[1] ?? null) : null;
+            })
+            : [],
+    ]);
+    const packageDirs = new Map();
+    names.forEach((name, i) => {
+        if (name && !packageDirs.has(name))
+            packageDirs.set(name, dirs[i]);
+    });
+    const goDirs = ['', ...dirs];
+    const goModules = modules.flatMap((module, i) => (module ? [{ module, dir: goDirs[i] }] : []));
+    return { goModules, packageDirs };
+}
+//# sourceMappingURL=imports.js.map