@loomhelix/deptrail 0.1.0

package/dist/actions/fix-options.js

@@ -0,0 +1,141 @@
+import semver from 'semver';
+import { IMPORTER_PREFIX } from "../model.js";
+import { nodeAdvisories, nodeMeta, worstSeverity } from "../query/enrichment-lookup.js";
+import { combineFixes } from "../query/fixes.js";
+import { findNode } from "../query/lookup.js";
+import { edgeFixes, normalizedRequestedRange, safeCandidates } from "../query/node-fix.js";
+import { acceptedClause, importerLabel } from "./labels.js";
+import { parentChain } from "./parent-chain.js";
+const ROOT_IMPORTER_ID = `${IMPORTER_PREFIX}.`;
+const NO_COMMON_SAFE_VERSION = 'the requesting ranges have no safe version in common';
+const NPM_DIRECT_DEPENDENCY = 'npm does not allow an override of a direct dependency of the root package; update it instead';
+const MAJOR_JUMP = 'major jump';
+export const NPM_LOCKFILE_OVERRIDES_VERSION = '11.2.0';
+export function npmIgnoresLockfileOverrides(manager) {
+    if (manager.name !== 'npm')
+        return false;
+    const version = semver.coerce(manager.version);
+    return version !== null && semver.lt(version, NPM_LOCKFILE_OVERRIDES_VERSION);
+}
+function lockfileOverridesReason(manager) {
+    return `npm ${manager.version} does not apply overrides to an existing lockfile, npm ${NPM_LOCKFILE_OVERRIDES_VERSION} and later do`;
+}
+function knownRanges(ranges) {
+    const known = ranges.filter((range) => range !== undefined);
+    return known.length === ranges.length ? known : undefined;
+}
+export function relockTarget(ranges, candidates) {
+    const known = knownRanges(ranges);
+    if (known === undefined)
+        return undefined;
+    return candidates
+        .filter((candidate) => semver.valid(candidate) !== null && known.every((range) => semver.satisfies(candidate, range)))
+        .sort(semver.compare)
+        .at(-1);
+}
+function fixGoal(node, advisories) {
+    return {
+        kind: 'fix',
+        name: node.name,
+        version: node.version,
+        advisoryIds: advisories.map((advisory) => advisory.id),
+        severity: worstSeverity(advisories.map((advisory) => advisory.severity)) ?? 'unknown',
+    };
+}
+function parentLabel(root, edge) {
+    if (edge.parentIsImporter)
+        return importerLabel(edge.parent);
+    return findNode(root, edge.parent)?.name ?? edge.parent;
+}
+function requestingRanges(context, node, edges) {
+    const meta = nodeMeta(context.view, context.root, node);
+    return edges.map((edge) => ({
+        label: parentLabel(context.root, edge),
+        declared: edge.range.range,
+        range: normalizedRequestedRange(context.root, node, meta, edge.range),
+    }));
+}
+function relockOption(node, target, requesting) {
+    const labels = [...new Set(requesting.map((entry) => entry.label))];
+    const step = { kind: 'relock', name: node.name, from: node.version, to: target, reason: acceptedClause(labels) };
+    return { choice: 'relock', steps: [step], warnings: [] };
+}
+async function chainOption(context, node, safe) {
+    const chain = await parentChain({ view: context.view, root: context.root, node, safe, kinds: context.kinds, loadVersions: context.loadVersions });
+    return 'steps' in chain ? { choice: 'chain', steps: chain.steps, warnings: [] } : { choice: 'chain', reason: chain.unavailable };
+}
+function overrideTarget(current, safe) {
+    if (semver.valid(current) === null)
+        return undefined;
+    const above = safe.filter((version) => semver.valid(version) !== null && semver.gt(version, current)).sort(semver.compare);
+    const highestSameMajor = above.filter((version) => semver.major(version) === semver.major(current)).at(-1);
+    if (highestSameMajor !== undefined)
+        return { version: highestSameMajor, majorJump: false };
+    const lowest = above[0];
+    return lowest === undefined ? undefined : { version: lowest, majorJump: true };
+}
+function rootDeclares(root, name) {
+    const rootImporter = root.importers.find((importer) => importer.id === ROOT_IMPORTER_ID);
+    return rootImporter?.deps.some((edge) => findNode(root, edge.to)?.name === name) ?? false;
+}
+function overrideReason(target, requesting) {
+    const excluding = requesting.find((entry) => entry.range !== undefined && !semver.satisfies(target, entry.range));
+    return excluding === undefined ? `forces ${target}` : `forces ${target} although ${excluding.label} declares ${excluding.declared}`;
+}
+function overrideOption(context, node, safe, requesting) {
+    const target = overrideTarget(node.version, safe);
+    if (target === undefined)
+        return { choice: 'override', reason: `no safe version of ${node.name} above ${node.version}` };
+    if (context.manager.name === 'npm' && rootDeclares(context.root, node.name))
+        return { choice: 'override', reason: NPM_DIRECT_DEPENDENCY };
+    if (npmIgnoresLockfileOverrides(context.manager))
+        return { choice: 'override', reason: lockfileOverridesReason(context.manager) };
+    const step = {
+        kind: 'override',
+        selector: `${node.name}@<${target.version}`,
+        value: target.version,
+        file: context.overrides.file,
+        reason: overrideReason(target.version, requesting),
+    };
+    const locationWarnings = context.overrides.warning === undefined ? [] : [context.overrides.warning];
+    return { choice: 'override', steps: [step], warnings: [...(target.majorJump ? [MAJOR_JUMP] : []), ...locationWarnings] };
+}
+async function optionOutcomes(context, node, kind, edges) {
+    const safe = safeCandidates(context.view, context.root, node, nodeMeta(context.view, context.root, node)) ?? [];
+    const requesting = requestingRanges(context, node, edges);
+    if (kind === 'relock') {
+        const target = relockTarget(requesting.map((entry) => entry.range), safe);
+        const needsLockfileOverride = edges.some((edge) => !edge.parentIsImporter);
+        if (target !== undefined && needsLockfileOverride && npmIgnoresLockfileOverrides(context.manager)) {
+            return [{ choice: 'relock', reason: lockfileOverridesReason(context.manager) }, overrideOption(context, node, safe, requesting)];
+        }
+        if (target !== undefined)
+            return [relockOption(node, target, requesting)];
+        return [{ choice: 'relock', reason: NO_COMMON_SAFE_VERSION }, overrideOption(context, node, safe, requesting)];
+    }
+    return [await chainOption(context, node, safe), overrideOption(context, node, safe, requesting)];
+}
+function isUnavailable(outcome) {
+    return 'reason' in outcome;
+}
+function collectOptions(goal, outcomes) {
+    const offered = outcomes.filter((outcome) => !isUnavailable(outcome));
+    return {
+        goal,
+        options: offered.map((option, index) => ({ choice: option.choice, recommended: index === 0, steps: option.steps, warnings: option.warnings })),
+        unavailable: outcomes.filter(isUnavailable),
+    };
+}
+export async function fixActions(context, node) {
+    const advisories = nodeAdvisories(context.view, context.root, node);
+    if (advisories.length === 0)
+        return undefined;
+    const goal = fixGoal(node, advisories);
+    const edges = edgeFixes(context.view, context.root, node, context.kinds);
+    const { kind } = combineFixes(edges);
+    if (kind === 'no-fix')
+        return { goal, options: [], unavailable: [], reason: `No published version of ${node.name} is free of these advisories` };
+    if (kind === 'unknown')
+        return { goal, options: [], unavailable: [], reason: `Registry or advisory data for ${node.name} is incomplete` };
+    return collectOptions(goal, await optionOutcomes(context, node, kind, edges));
+}

package/dist/actions/goal-check.js

@@ -0,0 +1,80 @@
+import semver from 'semver';
+import { IMPORTER_PREFIX, PLACEHOLDER_PREFIX } from "../model.js";
+import { compareVersions, packageVersions } from "../query/graph-diff.js";
+import { isAffected } from "../query/versions.js";
+import { importerLabel } from "./labels.js";
+function parentText(graph, id) {
+    if (id.startsWith(IMPORTER_PREFIX))
+        return importerLabel(id);
+    const parent = graph.packages.get(id);
+    return parent === undefined ? id : `${parent.name} ${parent.version}`;
+}
+function remainingPathText(graph, nodes, version) {
+    const parent = nodes.find((node) => node.dependents.length > 0)?.dependents[0];
+    return parent === undefined ? `${version} is still in the lockfile` : `${version} is still required by ${parentText(graph, parent)}`;
+}
+function loadedAdvisories(view, name) {
+    const loaded = view.advisoriesOf(name);
+    return loaded.state === 'ok' || loaded.state === 'stale' ? loaded.advisories : [];
+}
+function packagesNamed(graph, name) {
+    return [...graph.packages.values()].filter((node) => node.name === name && !node.id.startsWith(PLACEHOLDER_PREFIX));
+}
+function checkFix(goal, before, after, view) {
+    const remaining = packagesNamed(after, goal.name);
+    const targeted = remaining.filter((node) => node.version === goal.version);
+    if (targeted.length > 0)
+        return { met: false, detail: remainingPathText(after, targeted, goal.version) };
+    const versions = [...new Set(remaining.map((node) => node.version))].sort(compareVersions);
+    const previous = packageVersions(before).get(goal.name);
+    const advisories = loadedAdvisories(view, goal.name);
+    for (const version of versions.filter((candidate) => !previous?.has(candidate))) {
+        const advisory = advisories.find((candidate) => isAffected(version, candidate));
+        if (advisory !== undefined)
+            return { met: false, detail: `${version} is affected by ${advisory.id}` };
+    }
+    if (versions.length === 0)
+        return { met: true, detail: `${goal.name} is no longer in the lockfile` };
+    return { met: true, detail: `no affected version left (${versions.join(', ')})` };
+}
+function joinLabels(labels) {
+    if (labels.length <= 1)
+        return labels.join('');
+    if (labels.length === 2)
+        return `${labels[0]} and ${labels[1]}`;
+    return `${labels.slice(0, -1).join(', ')}, and ${labels[labels.length - 1]}`;
+}
+function reachesTarget(version, target) {
+    return semver.valid(version) !== null && semver.valid(target) !== null && semver.gte(version, target);
+}
+function outsideWrittenRange(version, range) {
+    return semver.validRange(range) !== null && semver.valid(version) !== null && !semver.satisfies(version, range);
+}
+function checkUpdate(goal, after) {
+    const resolved = new Set();
+    for (const importerId of goal.importers) {
+        const label = importerLabel(importerId);
+        const importer = after.importers.find((candidate) => candidate.id === importerId);
+        const resolutions = (importer?.deps ?? []).flatMap((edge) => {
+            const node = edge.kind === 'peer' ? undefined : after.packages.get(edge.to);
+            return node?.name === goal.name ? [{ range: edge.range, version: node.version }] : [];
+        });
+        if (resolutions.length === 0)
+            return { met: false, detail: `${label} no longer depends on ${goal.name}` };
+        for (const { range, version } of resolutions) {
+            if (!reachesTarget(version, goal.target))
+                return { met: false, detail: `${label} resolves ${goal.name} ${version}, below ${goal.target}` };
+            if (outsideWrittenRange(version, range))
+                return { met: false, detail: `${label} resolves ${goal.name} ${version}, outside ${range}` };
+            resolved.add(version);
+        }
+    }
+    const versions = [...resolved].sort(compareVersions).join(', ');
+    return { met: true, detail: `${goal.name} ${versions} in ${joinLabels(goal.importers.map(importerLabel))}` };
+}
+export function checkGoals(items, before, after, view) {
+    return items.map((item) => ({
+        itemId: item.id,
+        ...(item.goal.kind === 'fix' ? checkFix(item.goal, before, after, view) : checkUpdate(item.goal, after)),
+    }));
+}

package/dist/actions/install.js

@@ -0,0 +1,27 @@
+import { FROZEN_INSTALL_ARGS, INSTALL_TIMEOUT_MS, commandText } from "./recipes.js";
+export async function runFrozenInstall(input) {
+    const args = FROZEN_INSTALL_ARGS[input.manager];
+    const text = commandText(input.manager, args);
+    try {
+        const result = await input.runner.run({
+            command: input.manager,
+            args,
+            cwd: input.rootDir,
+            env: input.env,
+            timeoutMs: INSTALL_TIMEOUT_MS,
+            signal: input.signal,
+            onLine: (line) => input.onLine(input.secrets.redact(line)),
+        });
+        if (result.cancelled)
+            return { ok: false, reason: 'canceled', cancelled: true };
+        if (result.timedOut)
+            return { ok: false, reason: `${text} did not finish within ${INSTALL_TIMEOUT_MS / 60_000} minutes`, cancelled: false };
+        if (result.code !== 0)
+            return { ok: false, reason: `${text} exited with code ${result.code}`, cancelled: false };
+        return { ok: true };
+    }
+    catch (failure) {
+        const reason = failure.code === 'ENOENT' ? `${input.manager} was not found` : `${input.manager} could not be started`;
+        return { ok: false, reason, cancelled: false };
+    }
+}

package/dist/actions/job-registry.js

@@ -0,0 +1,104 @@
+import { randomUUID } from 'node:crypto';
+import { processSecrets } from "../config/secrets.js";
+import { messageOf } from "../scan/build-root.js";
+export const JOB_LOG_LINES = 2000;
+function snapshot(record, since) {
+    const firstLine = Math.max(since, record.droppedLines);
+    return {
+        id: record.id,
+        rootId: record.rootId,
+        kind: record.kind,
+        state: record.state,
+        ...(record.phase === undefined ? {} : { phase: record.phase }),
+        log: record.lines.slice(firstLine - record.droppedLines),
+        firstLine,
+        ...(record.error === undefined ? {} : { error: record.error }),
+        ...(record.result === undefined ? {} : { result: record.result }),
+    };
+}
+function startRun(run, context) {
+    try {
+        return run(context);
+    }
+    catch (failure) {
+        return Promise.reject(failure);
+    }
+}
+export function createJobRegistry(secrets = processSecrets) {
+    const records = new Map();
+    function appendLine(record, line) {
+        if (record.state !== 'running')
+            return;
+        record.lines.push(secrets.redact(line));
+        if (record.lines.length <= JOB_LOG_LINES)
+            return;
+        record.lines.shift();
+        record.droppedLines++;
+    }
+    function settle(record, outcome) {
+        if (record.controller.signal.aborted) {
+            record.state = 'cancelled';
+            return;
+        }
+        if ('failure' in outcome) {
+            record.state = 'failed';
+            record.error = secrets.redact(messageOf(outcome.failure));
+            return;
+        }
+        record.state = 'done';
+        if (outcome.result !== undefined)
+            record.result = outcome.result;
+    }
+    function dropFinished(rootId) {
+        for (const [id, record] of records) {
+            if (record.rootId === rootId && record.state !== 'running')
+                records.delete(id);
+        }
+    }
+    function newest(rootId, accepts) {
+        let found;
+        for (const record of records.values()) {
+            if (record.rootId === rootId && accepts(record))
+                found = record;
+        }
+        return found === undefined ? undefined : snapshot(found, 0);
+    }
+    return {
+        start(rootId, kind, run) {
+            dropFinished(rootId);
+            const record = { id: randomUUID(), rootId, kind, state: 'running', lines: [], droppedLines: 0, controller: new AbortController() };
+            records.set(record.id, record);
+            const context = {
+                signal: record.controller.signal,
+                log: (line) => appendLine(record, line),
+                phase: (phase) => {
+                    if (record.state === 'running')
+                        record.phase = phase;
+                },
+            };
+            startRun(run, context).then((result) => settle(record, { result }), (failure) => settle(record, { failure }));
+            return snapshot(record, 0);
+        },
+        get(id, since) {
+            const record = records.get(id);
+            return record === undefined ? undefined : snapshot(record, since);
+        },
+        running(rootId) {
+            return newest(rootId, (record) => record.state === 'running');
+        },
+        latest(rootId) {
+            return newest(rootId, () => true);
+        },
+        cancel(id) {
+            const record = records.get(id);
+            if (record?.state === 'running')
+                record.controller.abort();
+        },
+        cancelAll() {
+            for (const record of records.values()) {
+                if (record.state === 'running')
+                    record.controller.abort();
+            }
+        },
+    };
+}

package/dist/actions/json-edit.js

@@ -0,0 +1,189 @@
+export class JsonEditError extends Error {
+}
+const DEFAULT_INDENT_UNIT = '  ';
+const WHITESPACE = new Set([' ', '\t', '\n', '\r']);
+const VALUE_TERMINATORS = new Set([',', '}', ']', ...WHITESPACE]);
+class JsonScanner {
+    text;
+    position = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    parseDocument() {
+        const root = this.parseValue();
+        this.skipWhitespace();
+        if (this.position < this.text.length)
+            this.fail('unexpected content after the document');
+        return root;
+    }
+    fail(reason) {
+        throw new JsonEditError(`Malformed JSON at offset ${this.position}: ${reason}`);
+    }
+    skipWhitespace() {
+        while (this.position < this.text.length && WHITESPACE.has(this.text[this.position]))
+            this.position++;
+    }
+    parseValue() {
+        this.skipWhitespace();
+        const character = this.text[this.position];
+        if (character === undefined)
+            return this.fail('unexpected end of input');
+        if (character === '{')
+            return this.parseObject();
+        if (character === '[')
+            return this.parseArray();
+        if (character === '"') {
+            const start = this.position;
+            this.readString();
+            return { kind: 'string', start, end: this.position, members: [] };
+        }
+        return this.parseLiteral();
+    }
+    readString() {
+        const start = this.position;
+        this.position++;
+        while (this.position < this.text.length) {
+            const character = this.text[this.position];
+            if (character === '\\')
+                this.position += 2;
+            else if (character === '"') {
+                this.position++;
+                try {
+                    return JSON.parse(this.text.slice(start, this.position));
+                }
+                catch {
+                    return this.fail('invalid string');
+                }
+            }
+            else
+                this.position++;
+        }
+        return this.fail('unterminated string');
+    }
+    parseLiteral() {
+        const start = this.position;
+        while (this.position < this.text.length && !VALUE_TERMINATORS.has(this.text[this.position]))
+            this.position++;
+        try {
+            JSON.parse(this.text.slice(start, this.position));
+        }
+        catch {
+            this.position = start;
+            this.fail('invalid value');
+        }
+        return { kind: 'other', start, end: this.position, members: [] };
+    }
+    parseArray() {
+        const start = this.position;
+        this.position++;
+        this.skipWhitespace();
+        if (this.text[this.position] === ']') {
+            this.position++;
+            return { kind: 'other', start, end: this.position, members: [] };
+        }
+        for (;;) {
+            this.parseValue();
+            this.skipWhitespace();
+            const separator = this.text[this.position++];
+            if (separator === ']')
+                return { kind: 'other', start, end: this.position, members: [] };
+            if (separator !== ',') {
+                this.position--;
+                this.fail('expected , or ]');
+            }
+        }
+    }
+    parseObject() {
+        const start = this.position;
+        const members = [];
+        this.position++;
+        this.skipWhitespace();
+        if (this.text[this.position] === '}') {
+            this.position++;
+            return { kind: 'object', start, end: this.position, members };
+        }
+        for (;;) {
+            this.skipWhitespace();
+            if (this.text[this.position] !== '"')
+                this.fail('expected a string key');
+            const memberStart = this.position;
+            const key = this.readString();
+            this.skipWhitespace();
+            if (this.text[this.position] !== ':')
+                this.fail('expected :');
+            this.position++;
+            members.push({ key, start: memberStart, value: this.parseValue() });
+            this.skipWhitespace();
+            const separator = this.text[this.position++];
+            if (separator === '}')
+                return { kind: 'object', start, end: this.position, members };
+            if (separator !== ',') {
+                this.position--;
+                this.fail('expected , or }');
+            }
+        }
+    }
+}
+function lineStartOf(text, offset) {
+    return text.lastIndexOf('\n', offset - 1) + 1;
+}
+function leadingWhitespace(text, lineStart) {
+    let end = lineStart;
+    while (text[end] === ' ' || text[end] === '\t')
+        end++;
+    return text.slice(lineStart, end);
+}
+function detectIndentUnit(text) {
+    const match = /^([ \t]+)[^ \t\r\n]/m.exec(text);
+    return match ? match[1] : DEFAULT_INDENT_UNIT;
+}
+function renderMember(keys, value, indent, unit, lineBreak) {
+    const [key, ...rest] = keys;
+    if (rest.length === 0)
+        return `${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+    const innerIndent = indent + unit;
+    const inner = renderMember(rest, value, innerIndent, unit, lineBreak);
+    return `${JSON.stringify(key)}: {${lineBreak}${innerIndent}${inner}${lineBreak}${indent}}`;
+}
+function insertMember(text, object, keys, value) {
+    const lineBreak = text.includes('\r\n') ? '\r\n' : '\n';
+    const unit = detectIndentUnit(text);
+    const last = object.members[object.members.length - 1];
+    if (!last) {
+        const objectIndent = leadingWhitespace(text, lineStartOf(text, object.start));
+        const memberIndent = objectIndent + unit;
+        const member = renderMember(keys, value, memberIndent, unit, lineBreak);
+        return (text.slice(0, object.start + 1) +
+            lineBreak + memberIndent + member + lineBreak + objectIndent +
+            text.slice(object.end - 1));
+    }
+    const lastLineStart = lineStartOf(text, last.start);
+    const sharesLineWithBrace = lastLineStart <= object.start;
+    const memberIndent = leadingWhitespace(text, lastLineStart);
+    const separator = sharesLineWithBrace ? ', ' : `,${lineBreak}${memberIndent}`;
+    const member = renderMember(keys, value, memberIndent, unit, lineBreak);
+    return text.slice(0, last.value.end) + separator + member + text.slice(last.value.end);
+}
+export function setJsonString(text, path, value) {
+    if (path.length === 0)
+        throw new JsonEditError('The path is empty');
+    let current = new JsonScanner(text).parseDocument();
+    if (current.kind !== 'object')
+        throw new JsonEditError('The document is not an object');
+    for (let index = 0; index < path.length; index++) {
+        const key = path[index];
+        const member = current.members.filter((candidate) => candidate.key === key).at(-1);
+        if (!member)
+            return insertMember(text, current, path.slice(index), value);
+        const isLast = index === path.length - 1;
+        if (isLast) {
+            if (member.value.kind !== 'string')
+                throw new JsonEditError(`${path.join('.')} is not a string`);
+            return text.slice(0, member.value.start) + JSON.stringify(value) + text.slice(member.value.end);
+        }
+        if (member.value.kind !== 'object')
+            throw new JsonEditError(`${path.slice(0, index + 1).join('.')} is not an object`);
+        current = member.value;
+    }
+    throw new JsonEditError('The path was not resolved');
+}

package/dist/actions/labels.js

@@ -0,0 +1,35 @@
+const IMPORTER_ID_PREFIX = 'importer:';
+export const REPOSITORY_ROOT_ID = '.';
+export const INSTALL_FAILURE_PREFIX = 'install failed:';
+const ROOT_IMPORTER_ID = `${IMPORTER_ID_PREFIX}${REPOSITORY_ROOT_ID}`;
+const REPOSITORY_ROOT_LABEL = 'repository root';
+const LISTED_LABEL_LIMIT = 3;
+const FIELD_BY_KIND = {
+    prod: 'dependencies',
+    dev: 'devDependencies',
+    optional: 'optionalDependencies',
+    peer: undefined,
+};
+export function rootLabel(rootId) {
+    return rootId === REPOSITORY_ROOT_ID ? REPOSITORY_ROOT_LABEL : rootId;
+}
+export function importerLabel(id) {
+    if (id === ROOT_IMPORTER_ID)
+        return 'the root package';
+    return id.startsWith(IMPORTER_ID_PREFIX) ? id.slice(IMPORTER_ID_PREFIX.length) : id;
+}
+export function goalText(goal) {
+    return goal.kind === 'fix' ? `Fix ${goal.name} ${goal.version}` : `Update ${goal.name} to ${goal.target}`;
+}
+export function acceptedClause(labels) {
+    if (labels.length === 1)
+        return `${labels[0]} accepts it`;
+    if (labels.length === 2)
+        return `${labels[0]} and ${labels[1]} accept it`;
+    if (labels.length <= LISTED_LABEL_LIMIT)
+        return `${labels.slice(0, -1).join(', ')}, and ${labels[labels.length - 1]} accept it`;
+    return `${labels.slice(0, LISTED_LABEL_LIMIT).join(', ')}, and ${labels.length - LISTED_LABEL_LIMIT} more accept it`;
+}
+export function fieldOf(kind) {
+    return FIELD_BY_KIND[kind];
+}

package/dist/actions/node-actions.js

@@ -0,0 +1,102 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { IMPORTER_PREFIX, PLACEHOLDER_PREFIX } from "../model.js";
+import { ALL_KINDS, findNode } from "../query/lookup.js";
+import { ActionError } from "./action-error.js";
+import { ROOT_MANIFEST } from "./edit-plan.js";
+import { fixActions } from "./fix-options.js";
+import { overridesLocationOf, readTextOrNull, rootDirOf } from "./root-files.js";
+import { updateActions, updateSteps } from "./update-options.js";
+const NOT_FROM_REGISTRY = 'This package does not come from a registry';
+const INVALID_KINDS = 'Invalid kinds';
+const FIX_CHOICES = ['relock', 'chain', 'override'];
+const UPDATE_CHOICES = ['wanted', 'latest', 'version'];
+function isImporter(node) {
+    return node.id.startsWith(IMPORTER_PREFIX);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFixChoice(choice) {
+    return FIX_CHOICES.includes(choice);
+}
+function isUpdateChoice(choice) {
+    return UPDATE_CHOICES.includes(choice);
+}
+export function nodeLabel(node) {
+    return isImporter(node) ? node.name : `${node.name} ${node.version}`;
+}
+export function kindFilterOf(kinds) {
+    if (kinds === undefined)
+        return ALL_KINDS;
+    if (!Array.isArray(kinds) || kinds.length === 0 || !kinds.every((kind) => ALL_KINDS.has(kind)))
+        throw new ActionError(400, INVALID_KINDS);
+    return new Set(kinds);
+}
+function parsedManifest(text) {
+    if (text === null)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function manifestsDeclaring(repoPath, root, name) {
+    const importers = root.importers.filter((importer) => importer.deps.some((edge) => findNode(root, edge.to)?.name === name));
+    const manifests = new Map();
+    await Promise.all(importers.map(async (importer) => {
+        const manifest = parsedManifest(await readTextOrNull(path.join(repoPath, importer.path, ROOT_MANIFEST)));
+        if (manifest !== undefined)
+            manifests.set(importer.id, manifest);
+    }));
+    return manifests;
+}
+export async function actionsOfNode(context, node) {
+    if (isImporter(node))
+        return {};
+    if (node.id.startsWith(PLACEHOLDER_PREFIX) || node.nonRegistry === true)
+        return { unavailable: NOT_FROM_REGISTRY };
+    const { repoPath, enrichment, root, manager, kinds } = context;
+    const [overrides, manifests] = await Promise.all([overridesLocationOf(rootDirOf(repoPath, root), manager), manifestsDeclaring(repoPath, root, node.name)]);
+    const options = { view: enrichment, root, kinds, manager, overrides, loadVersions: (name) => enrichment.publishedVersions(root, name) };
+    const fix = await fixActions(options, node);
+    const update = updateActions(options, node, manifests);
+    return { ...(fix === undefined ? {} : { fix }), ...(update === undefined ? {} : { update }) };
+}
+function newItem(goal, choice, steps, warnings) {
+    return { id: randomUUID(), goal, choice, steps, warnings };
+}
+function notOffered(choice, node) {
+    return new ActionError(400, `${choice} is not offered for ${nodeLabel(node)}`);
+}
+function editableImporters(update) {
+    return update.importers.filter((importer) => importer.editable).map((importer) => importer.id);
+}
+function fixItem(goal, option) {
+    return newItem(goal, option.choice, option.steps, option.warnings);
+}
+export function requestedItem(root, node, actions, request) {
+    const { choice } = request;
+    const { fix, update } = actions;
+    if (choice === 'recommended') {
+        const option = fix?.options.find((candidate) => candidate.recommended);
+        if (fix === undefined || option === undefined)
+            throw new ActionError(400, `No fix is available for ${nodeLabel(node)}`);
+        return fixItem(fix.goal, option);
+    }
+    if (isFixChoice(choice)) {
+        const option = fix?.options.find((candidate) => candidate.choice === choice);
+        if (fix === undefined || option === undefined)
+            throw notOffered(choice, node);
+        return fixItem(fix.goal, option);
+    }
+    if (!isUpdateChoice(choice) || update === undefined)
+        throw notOffered(choice, node);
+    const plan = updateSteps(update, root, choice, request.version, request.importers ?? editableImporters(update));
+    if ('error' in plan)
+        throw new ActionError(400, plan.error);
+    return newItem(plan.goal, choice, plan.steps, plan.warnings);
+}