mergestory 0.0.0-stage → 1.0.0

package/dist/analyzer/analyze.d.ts

@@ -0,0 +1,8 @@
+import type { RunContext } from '../core/context.ts';
+import type { Analysis, ChangeSet, ContextInputs, RepoReader } from '../core/types.ts';
+/**
+ * Analyse a change set. File contents come only from `reader`, and never for a file marked
+ * `sensitive` (a sensitive or excluded path: the source decides). The result is deterministic: the
+ * same input gives the same ids.
+ */
+export declare function analyze(changeSet: ChangeSet, reader: RepoReader, inputs: ContextInputs, ctx: RunContext): Promise<Analysis>;

package/dist/analyzer/analyze.js

@@ -0,0 +1,328 @@
+/** The analysis pipeline: from a change set to the facts a storyboard may cite. */
+import { mapLimit } from '../core/concurrency.js';
+import { languageInfo } from '../core/languages.js';
+import { compileGlobs, isProtectedFile, isShowable } from '../core/path-policy.js';
+import { extname } from '../core/posix.js';
+import { groupComponents } from './components.js';
+import { diffManifest, manifestKind } from './dependencies.js';
+import { buildEvidenceIndex } from './evidence.js';
+import { rankKeyHunks } from './hunks.js';
+import { ImportResolver, importLang, loadResolverOptions } from './imports.js';
+import { hasImports, hasSymbols } from './languages/index.js';
+import { buildRelationships } from './relationships.js';
+import { detectRisks } from './risks.js';
+import { detectRole, ROLE_WEIGHT } from './roles.js';
+import { architectureSignals } from './signals.js';
+import { classifySymbols } from './symbol-changes.js';
+import { classifyTrivial } from './trivial.js';
+import { round } from './util.js';
+const MAX_CONTENT_FILES = 150;
+const MAX_SYMBOLS = 80;
+const READ_CONCURRENCY = 6;
+const CONTENT_ROLES = ['source', 'test', 'migration', 'build', 'other'];
+const KIND_WEIGHT = {
+    route: 1,
+    class: 0.9,
+    component: 0.9,
+    function: 0.8,
+    interface: 0.8,
+    type: 0.6,
+    method: 0.6,
+    constant: 0.4,
+    other: 0.3,
+};
+const CHANGE_WEIGHT = { added: 1, removed: 0.9, modified: 0.6 };
+function sizeOf(lines) {
+    if (lines <= 20)
+        return 'xs';
+    if (lines <= 120)
+        return 's';
+    if (lines <= 400)
+        return 'm';
+    if (lines <= 1200)
+        return 'l';
+    return 'xl';
+}
+const DURATION = { xs: 45, s: 70, m: 100, l: 130, xl: 160 };
+function changedText(file) {
+    return file.hunks.flatMap((h) => h.lines.filter((l) => l.kind !== 'ctx').map((l) => l.text)).join('\n');
+}
+/** Gives every changed file its role and its verdicts: protected, trivial, comment-only. */
+function classifyFiles(files) {
+    return files.map((file, index) => {
+        const hidden = isProtectedFile(file);
+        const role = detectRole(file.path, !hidden && extname(file.path) === '.sql' ? changedText(file) : '');
+        const verdict = hidden
+            ? { trivial: false, reason: null, commentOnly: false }
+            : classifyTrivial(file, role);
+        return {
+            index,
+            file,
+            role,
+            hidden,
+            trivial: verdict.trivial,
+            trivialReason: verdict.reason,
+            commentOnly: verdict.commentOnly,
+        };
+    });
+}
+/** A file whose content may be inspected and that counts as work: not protected, binary or trivial. */
+function isContent(s) {
+    return isShowable(s.file) && !s.trivial && CONTENT_ROLES.includes(s.role);
+}
+/** The files worth reading, biggest first: those that can yield symbols or imports. */
+function selectContentFiles(states) {
+    return states
+        .filter((s) => isContent(s) && (hasSymbols(s.file.path) || hasImports(s.file.path)))
+        .sort((a, b) => b.file.additions + b.file.deletions - (a.file.additions + a.file.deletions) || a.index - b.index)
+        .slice(0, MAX_CONTENT_FILES);
+}
+/** Reads of repository files for one run: cached, and a failed read is a missing file unless the run was cancelled. */
+function createFileReader(reader, ctx) {
+    const cache = new Map();
+    const read = (path, side) => {
+        const key = `${side}:${path}`;
+        let hit = cache.get(key);
+        if (!hit) {
+            hit = reader.readFile(path, side).catch((err) => {
+                if (ctx.signal.aborted)
+                    throw err;
+                ctx.logger.debug('analyzer: could not read a file', { side });
+                return null;
+            });
+            cache.set(key, hit);
+        }
+        return hit;
+    };
+    return {
+        read,
+        head: (s) => s.file.status === 'deleted' ? Promise.resolve(null) : read(s.file.path, 'head'),
+        base: (s) => s.file.status === 'added' || s.file.status === 'copied'
+            ? Promise.resolve(null)
+            : read(s.file.oldPath ?? s.file.path, 'base'),
+    };
+}
+/** Reads head and, where deletions need it, base of each content file, and finds the symbols that changed. */
+function readContent(states, files, ctx) {
+    return mapLimit(states, READ_CONCURRENCY, async (s) => {
+        ctx.signal.throwIfAborted();
+        const needsBase = s.file.status === 'deleted' ||
+            ((s.role === 'source' || s.role === 'migration') && s.file.deletions > 0 && s.file.status !== 'added');
+        const [head, base] = await Promise.all([files.head(s), needsBase ? files.base(s) : null]);
+        const reports = s.role === 'source' || s.role === 'migration' || s.role === 'other';
+        return { state: s, head, symbols: reports ? classifySymbols(s.file, head, base) : [] };
+    });
+}
+/** Dependency changes of the manifests in the change, numbered in file order. */
+async function readDependencies(states, files) {
+    const manifests = states.filter((s) => !s.hidden && s.role === 'dependency-manifest' && manifestKind(s.file.path) !== null);
+    const diffs = await mapLimit(manifests, READ_CONCURRENCY, async (s) => {
+        const [base, head] = await Promise.all([files.base(s), files.head(s)]);
+        return diffManifest(s.file, base, head);
+    });
+    return diffs.flat().map((d, i) => ({ ...d, id: `D${i + 1}` }));
+}
+/** Keeps the most relevant symbols, then numbers them in file order. */
+function pickSymbols(reads) {
+    const candidates = [...reads]
+        .sort((a, b) => a.state.index - b.state.index)
+        .flatMap(({ state, symbols }) => symbols.map((symbol) => ({ state, symbol })));
+    const relevance = (c) => KIND_WEIGHT[c.symbol.kind] *
+        CHANGE_WEIGHT[c.symbol.change] *
+        (c.symbol.exported ? 1 : 0.6) *
+        Math.max(0.1, ROLE_WEIGHT[c.state.role]);
+    const kept = candidates
+        .map((c, order) => ({ c, order, score: relevance(c) }))
+        .sort((a, b) => b.score - a.score || a.order - b.order)
+        .slice(0, MAX_SYMBOLS)
+        .sort((a, b) => a.order - b.order);
+    const identified = kept.map(({ c }, i) => {
+        const { signatureChanged, decl: _decl, ...rest } = c.symbol;
+        return { ...rest, id: `S${i + 1}`, signatureChanged };
+    });
+    return { identified, symbols: identified.map(({ signatureChanged: _s, ...rest }) => rest) };
+}
+/** Size class, line count and suggested length of the video. */
+function pacing(states, grouping) {
+    let meaningfulLines = 0;
+    for (const s of states) {
+        if (isShowable(s.file) && !s.trivial)
+            meaningfulLines += s.file.additions + s.file.deletions;
+    }
+    const size = sizeOf(meaningfulLines);
+    const stateById = new Map(states.map((s) => [s.file.id, s]));
+    const meaningfulComponents = grouping.components.filter((m) => m.fileIds.some((id) => {
+        const s = stateById.get(id);
+        return (!!s && !s.hidden && !s.trivial && !['docs', 'test', 'asset', 'lockfile', 'generated'].includes(s.role));
+    })).length;
+    return {
+        meaningfulLines,
+        size,
+        suggestedDurationSec: DURATION[size] + (meaningfulComponents >= 3 ? 10 : 0),
+    };
+}
+function insightsOf(states, symbols, risks, grouping) {
+    const symbolsByFile = new Map();
+    for (const s of symbols)
+        symbolsByFile.set(s.fileId, [...(symbolsByFile.get(s.fileId) ?? []), s]);
+    return states.map((s) => {
+        const churn = s.file.additions + s.file.deletions;
+        const fileSymbols = symbolsByFile.get(s.file.id) ?? [];
+        let importance = 0.1;
+        if (!s.hidden) {
+            if (s.trivial)
+                importance = 0;
+            else {
+                importance = ROLE_WEIGHT[s.role] * (0.35 + 0.65 * Math.min(1, Math.log1p(churn) / Math.log1p(150)));
+                if (s.commentOnly)
+                    importance *= 0.4;
+                if (fileSymbols.some((x) => x.exported && x.change === 'added'))
+                    importance += 0.1;
+                importance += Math.min(0.15, 0.05 * risks.filter((r) => r.evidence.includes(s.file.id)).length);
+            }
+        }
+        return {
+            fileId: s.file.id,
+            path: s.file.path,
+            role: s.role,
+            componentId: grouping.byFile.get(s.file.id) ?? 'M1',
+            hidden: s.hidden,
+            trivial: s.trivial,
+            trivialReason: s.trivialReason,
+            importance: round(Math.min(1, Math.max(0, importance))),
+            symbolIds: fileSymbols.map((x) => x.id),
+        };
+    });
+}
+function testChanges(states) {
+    const tests = { added: [], modified: [], removed: [] };
+    for (const s of states) {
+        if (s.hidden || s.role !== 'test')
+            continue;
+        if (s.file.status === 'added' || s.file.status === 'copied')
+            tests.added.push(s.file.path);
+        else if (s.file.status === 'deleted')
+            tests.removed.push(s.file.path);
+        else
+            tests.modified.push(s.file.path);
+    }
+    return tests;
+}
+function languagesOf(states) {
+    const counts = new Map();
+    for (const s of states) {
+        if (!isContent(s))
+            continue;
+        const language = s.file.language ? languageInfo(s.file.language) : null;
+        if (language?.isCode)
+            counts.set(language.base, (counts.get(language.base) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([language, files]) => ({ language, files }))
+        .sort((a, b) => b.files - a.files || a.language.localeCompare(b.language));
+}
+/**
+ * Analyse a change set. File contents come only from `reader`, and never for a file marked
+ * `sensitive` (a sensitive or excluded path: the source decides). The result is deterministic: the
+ * same input gives the same ids.
+ */
+export async function analyze(changeSet, reader, inputs, ctx) {
+    const states = classifyFiles(changeSet.files);
+    ctx.signal.throwIfAborted();
+    const files = createFileReader(reader, ctx);
+    const contentStates = selectContentFiles(states);
+    const grouping = groupComponents(states.map((s) => ({ file: s.file, role: s.role, trivial: s.trivial })));
+    const languages = new Set(contentStates.flatMap((s) => {
+        const lang = importLang(s.file.path);
+        return lang ? [lang] : [];
+    }));
+    const isExcluded = compileGlobs(ctx.config.privacy.excludePaths);
+    // None of these reads needs another's result.
+    const [contents, dependencies, resolverOptions] = await Promise.all([
+        readContent(contentStates, files, ctx),
+        readDependencies(states, files),
+        loadResolverOptions({
+            componentPaths: grouping.components.map((m) => m.path),
+            languages,
+            isExcluded,
+            readHead: (path) => files.read(path, 'head'),
+            concurrency: READ_CONCURRENCY,
+        }),
+    ]);
+    const { identified, symbols } = pickSymbols(contents);
+    ctx.signal.throwIfAborted();
+    const knownPaths = new Set();
+    for (const s of states)
+        if (s.file.status !== 'deleted')
+            knownPaths.add(s.file.path);
+    for (const entry of changeSet.repoContext.tree)
+        knownPaths.add(entry.replace(/\/+$/, ''));
+    const relationships = buildRelationships({
+        files: contents.map(({ state, head }) => ({ file: state.file, role: state.role, head })),
+        grouping,
+        resolver: new ImportResolver({ knownPaths, ...resolverOptions }),
+    });
+    ctx.signal.throwIfAborted();
+    const { meaningfulLines, size, suggestedDurationSec } = pacing(states, grouping);
+    const riskResult = detectRisks({
+        files: states.map((s) => ({
+            file: s.file,
+            role: s.role,
+            trivial: s.trivial,
+            commentOnly: s.commentOnly,
+            hidden: s.hidden,
+        })),
+        symbols: identified,
+        dependencies,
+        inputs,
+        meaningfulLines,
+    });
+    const keyHunks = rankKeyHunks(states, symbols, riskResult.risks);
+    const fileInsights = insightsOf(states, symbols, riskResult.risks, grouping);
+    const stateById = new Map(states.map((s) => [s.file.id, s]));
+    const signals = architectureSignals({
+        components: grouping.components,
+        files: fileInsights.map((f) => {
+            const file = stateById.get(f.fileId)?.file;
+            return { ...f, status: file?.status ?? 'modified', oldPath: file?.oldPath ?? null };
+        }),
+        dependencies,
+        symbols,
+        envVars: riskResult.envVars,
+        cliCommands: riskResult.cliCommands,
+    });
+    const evidence = buildEvidenceIndex({
+        changeSet,
+        inputs,
+        hiddenFileIds: new Set(states.filter((s) => s.hidden).map((s) => s.file.id)),
+        components: grouping.components,
+        symbols,
+        risks: riskResult.risks,
+        dependencies,
+    });
+    ctx.logger.debug('analyzer: done', {
+        files: states.length,
+        contentFiles: contentStates.length,
+        symbols: symbols.length,
+        risks: riskResult.risks.length,
+        evidence: evidence.length,
+    });
+    return {
+        version: 1,
+        size,
+        meaningfulLines,
+        files: fileInsights,
+        components: grouping.components,
+        relationships,
+        symbols,
+        keyHunks,
+        risks: riskResult.risks,
+        dependencies,
+        tests: testChanges(states),
+        languages: languagesOf(states),
+        architectureSignals: signals,
+        suggestedDurationSec,
+        evidence,
+    };
+}
+//# sourceMappingURL=analyze.js.map

package/dist/analyzer/components.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Component (module) grouping. A component is the unit shown as one box in an architecture view:
+ * a monorepo package, or the first meaningful directory under a source root.
+ */
+import type { ChangedFile, Component, FileRole } from '../core/types.ts';
+export interface ComponentInput {
+    file: ChangedFile;
+    role: FileRole;
+    trivial: boolean;
+}
+export interface ComponentGrouping {
+    components: Component[];
+    /** File id -> component id. */
+    byFile: Map<string, string>;
+    /** Owning component of any repository path (changed or not), or null when no changed component owns it. */
+    componentForPath(path: string): string | null;
+}
+export declare function groupComponents(inputs: readonly ComponentInput[]): ComponentGrouping;

package/dist/analyzer/components.js

@@ -0,0 +1,266 @@
+/**
+ * Component (module) grouping. A component is the unit shown as one box in an architecture view:
+ * a monorepo package, or the first meaningful directory under a source root.
+ */
+import { basename, dirname } from '../core/posix.js';
+import { SOURCE_ROOTS } from './roles.js';
+const MONOREPO_PREFIXES = new Set(['packages', 'apps', 'services', 'libs', 'crates', 'modules', 'cmd']);
+const WRAPPER_DIRS = new Set(['features', 'modules', 'domains']);
+const TEST_DIRS = new Set(['__tests__', '__mocks__', 'tests', 'test', 'spec', 'specs', 'e2e', 'testdata']);
+const DOC_DIRS = new Set(['docs', 'doc', 'documentation']);
+const REVERSE_DOMAIN = new Set([
+    'com',
+    'org',
+    'net',
+    'io',
+    'de',
+    'fr',
+    'uk',
+    'nl',
+    'jp',
+    'cn',
+    'in',
+    'br',
+    'ch',
+]);
+const ROOT = { key: '.', name: 'Project root', path: '.' };
+const KIND_KEYWORDS = [
+    ['api', /^(api|apis|routes?|controllers?|handlers?|endpoints?)$/],
+    ['ui', /^(components?|ui|pages?|views?|screens?)$/],
+    ['data', /^(db|database|models?|migrations?|schemas?|repositories|repository)$/],
+    ['cli', /^(cli|bin|cmd|commands?)$/],
+    ['infra', /^(infra|infrastructure|terraform|k8s|kubernetes|helm|deploy|deployment)$/],
+    ['tests', /^(tests?|__tests__|spec|specs|e2e)$/],
+    ['docs', /^(docs?|documentation)$/],
+    ['config', /^(config|configs|configuration)$/],
+];
+function tokens(text) {
+    return text
+        .toLowerCase()
+        .split(/[\\/\-_.\s]+/)
+        .filter(Boolean);
+}
+function kindFromTokens(segments) {
+    for (const segment of segments) {
+        const parts = tokens(segment);
+        for (const [kind, pattern] of KIND_KEYWORDS) {
+            if (pattern.test(segment.toLowerCase()) || parts.some((p) => pattern.test(p)))
+                return kind;
+        }
+    }
+    return null;
+}
+/**
+ * First meaningful directory below a source root: skips the JVM layout (src/main/java) and
+ * reverse-domain package prefixes (com/acme). Returns the skipped segments and the ones kept.
+ */
+function meaningfulUnder(dirs) {
+    let i = 0;
+    if (dirs[0] === 'main' && ['java', 'kotlin', 'scala', 'groovy'].includes(dirs[1] ?? ''))
+        i = 2;
+    if (REVERSE_DOMAIN.has(dirs[i] ?? '') && dirs.length - i >= 3)
+        i += 2;
+    const first = dirs[i];
+    if (first === undefined)
+        return null;
+    const skipped = dirs.slice(0, i);
+    if (WRAPPER_DIRS.has(first) && dirs[i + 1] !== undefined)
+        return { skipped, kept: [first, dirs[i + 1]] };
+    return { skipped, kept: [first] };
+}
+/** Where a path lives, by layout alone. */
+function locate(path) {
+    const dirs = path.split('/').slice(0, -1);
+    const first = dirs[0];
+    if (first === undefined)
+        return ROOT;
+    if (MONOREPO_PREFIXES.has(first) && dirs.length >= 2) {
+        const second = dirs[1];
+        return { key: `${first}/${second}`, name: second, path: `${first}/${second}` };
+    }
+    if (SOURCE_ROOTS.has(first)) {
+        const meaningful = meaningfulUnder(dirs.slice(1));
+        if (meaningful) {
+            const full = [first, ...meaningful.skipped, ...meaningful.kept].join('/');
+            return { key: full, name: meaningful.kept[meaningful.kept.length - 1], path: full };
+        }
+    }
+    return { key: first, name: first, path: first };
+}
+function stripTestDirs(path) {
+    const parts = path.split('/');
+    return parts.filter((p, i) => i === parts.length - 1 || !TEST_DIRS.has(p.toLowerCase())).join('/');
+}
+function fileStem(path, testSuffixes) {
+    let name = basename(path)
+        .toLowerCase()
+        .replace(/\.[^.]+$/, '');
+    if (testSuffixes)
+        name = name
+            .replace(/\.(test|spec)$/, '')
+            .replace(/(_test|_spec|-test|-spec)$/, '')
+            .replace(/^test_/, '');
+    return name;
+}
+export function groupComponents(inputs) {
+    const placements = new Map();
+    const pending = [];
+    for (const input of inputs) {
+        const { file, role } = input;
+        if (role === 'ci') {
+            placements.set(file.id, {
+                key: 'ci',
+                name: 'CI',
+                path: file.path.split('/')[0]?.startsWith('.') ? file.path.split('/')[0] : '.',
+                ci: true,
+            });
+        }
+        else if (role === 'test' && stripTestDirs(file.path) !== file.path) {
+            pending.push(input);
+        }
+        else if (DOC_DIRS.has(file.path.split('/')[0] ?? '') && file.path.includes('/')) {
+            pending.push(input);
+        }
+        else {
+            placements.set(file.id, locate(file.path));
+        }
+    }
+    const byKey = new Map();
+    const byName = new Map();
+    const byStem = new Map();
+    const stemOwner = (stem, key) => {
+        byStem.set(stem, [...(byStem.get(stem) ?? []), key]);
+    };
+    for (const input of inputs) {
+        const p = placements.get(input.file.id);
+        if (!p)
+            continue;
+        byKey.set(p.key, p);
+        const nameKey = p.name.toLowerCase();
+        if (!(byName.get(nameKey) ?? []).includes(p.key))
+            byName.set(nameKey, [...(byName.get(nameKey) ?? []), p.key]);
+        if (input.role !== 'test')
+            stemOwner(fileStem(input.file.path, false), p.key);
+    }
+    const unique = (keys) => {
+        const set = [...new Set(keys ?? [])];
+        return set.length === 1 ? set[0] : null;
+    };
+    for (const input of pending) {
+        const { file, role } = input;
+        const original = locate(file.path);
+        if (role === 'test') {
+            const stripped = locate(stripTestDirs(file.path));
+            const topIsTestDir = TEST_DIRS.has(file.path.split('/')[0]?.toLowerCase() ?? '');
+            // A test at the repository root of its test folder says nothing about the root component.
+            const named = stripped.key !== ROOT.key;
+            const folded = (named && byKey.has(stripped.key) ? stripped.key : null) ??
+                (named ? unique(byName.get(stripped.name.toLowerCase())) : null) ??
+                unique(byStem.get(fileStem(file.path, true)));
+            if (folded)
+                placements.set(file.id, byKey.get(folded));
+            else
+                placements.set(file.id, topIsTestDir ? original : stripped);
+        }
+        else {
+            const folded = unique(byName.get(fileStem(file.path, false))) ?? unique(byStem.get(fileStem(file.path, false)));
+            placements.set(file.id, folded ? byKey.get(folded) : original);
+        }
+    }
+    // Duplicate short names (packages/api and services/api) fall back to the full path.
+    const nameCounts = new Map();
+    for (const p of placements.values()) {
+        const set = nameCounts.get(p.name) ?? new Set();
+        set.add(p.key);
+        nameCounts.set(p.name, set);
+    }
+    const buckets = new Map();
+    for (const input of inputs) {
+        const p = placements.get(input.file.id);
+        const bucket = buckets.get(p.key) ?? { located: p, inputs: [] };
+        bucket.inputs.push(input);
+        buckets.set(p.key, bucket);
+    }
+    const churn = (b) => b.inputs.reduce((n, i) => n + (i.trivial ? 0 : i.file.additions + i.file.deletions), 0);
+    const ordered = [...buckets.values()].sort((a, b) => churn(b) - churn(a) || a.located.path.localeCompare(b.located.path));
+    const components = [];
+    const keyToId = new Map();
+    const byFile = new Map();
+    ordered.forEach((bucket, index) => {
+        const id = `M${index + 1}`;
+        const { located } = bucket;
+        const files = bucket.inputs.map((i) => i.file);
+        const name = (nameCounts.get(located.name)?.size ?? 0) > 1 && !located.ci ? located.path : located.name;
+        components.push({
+            id,
+            name,
+            path: located.path,
+            kind: inferKind(located, bucket.inputs),
+            fileIds: files.map((f) => f.id),
+            additions: files.reduce((n, f) => n + f.additions, 0),
+            deletions: files.reduce((n, f) => n + f.deletions, 0),
+            status: files.every((f) => f.status === 'added')
+                ? 'added'
+                : files.every((f) => f.status === 'deleted')
+                    ? 'removed'
+                    : 'modified',
+        });
+        keyToId.set(located.key, id);
+        for (const f of files)
+            byFile.set(f.id, id);
+    });
+    const pathToFile = new Map(inputs.map((i) => [i.file.path, i.file.id]));
+    return {
+        components,
+        byFile,
+        componentForPath(path) {
+            const fileId = pathToFile.get(path);
+            if (fileId)
+                return byFile.get(fileId) ?? null;
+            return keyToId.get(locate(path).key) ?? null;
+        },
+    };
+}
+function inferKind(located, inputs) {
+    const roles = inputs.map((i) => i.role);
+    if (roles.every((r) => r === 'test'))
+        return 'tests';
+    if (roles.every((r) => r === 'docs'))
+        return 'docs';
+    if (roles.every((r) => r === 'asset'))
+        return 'ui';
+    if (located.ci || roles.every((r) => r === 'ci'))
+        return 'infra';
+    if (roles.every((r) => r === 'config' || r === 'dependency-manifest' || r === 'lockfile'))
+        return 'config';
+    if (located.key === '.' && !roles.some((r) => r === 'source' || r === 'migration'))
+        return 'config';
+    const fromName = kindFromTokens(located.path.split('/'));
+    if (fromName)
+        return fromName;
+    // Pick a kind when most source files sit in directories that name one (src/components/...).
+    const sources = inputs.filter((i) => i.role === 'source' || i.role === 'migration');
+    if (sources.length > 0 && sources.every((i) => /\.(tf|hcl)$/.test(i.file.path)))
+        return 'infra';
+    if (sources.length > 0) {
+        const counts = new Map();
+        for (const input of sources) {
+            const rel = dirname(input.file.path)
+                .split('/')
+                .slice(located.path === '.' ? 0 : located.path.split('/').length);
+            const kind = kindFromTokens(rel);
+            if (kind && kind !== 'tests' && kind !== 'docs' && kind !== 'config')
+                counts.set(kind, (counts.get(kind) ?? 0) + 1);
+        }
+        for (const [kind, n] of counts)
+            if (n / sources.length >= 0.6)
+                return kind;
+    }
+    const container = located.path.split('/')[0] ?? '';
+    if (container === 'services' || container === 'apps')
+        return 'service';
+    if (container === 'packages' || container === 'libs' || container === 'crates')
+        return 'package';
+    return 'module';
+}
+//# sourceMappingURL=components.js.map

package/dist/analyzer/dependencies.d.ts

@@ -0,0 +1,13 @@
+/** Dependency changes read from manifest files at base and head. */
+import type { ChangedFile, DependencyChange } from '../core/types.ts';
+export interface DependencyEntry {
+    name: string;
+    version: string;
+    dev: boolean;
+}
+type ManifestKind = 'package.json' | 'composer' | 'requirements' | 'go.mod' | 'cargo' | 'pyproject' | 'pipfile' | 'gemfile' | 'pom';
+export declare function manifestKind(path: string): ManifestKind | null;
+type DraftChange = Omit<DependencyChange, 'id'>;
+/** Dependency changes in one manifest file. `base` and `head` are file contents (null when absent). */
+export declare function diffManifest(file: ChangedFile, base: string | null, head: string | null): DraftChange[];
+export {};