@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/inspect-symbol-format.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInspectSelectorKind = exports.INSPECT_SELECTOR_KINDS = void 0;
+exports.formatSymbolReferencesArray = formatSymbolReferencesArray;
+exports.formatSymbolReference = formatSymbolReference;
+exports.formatEntityReference = formatEntityReference;
+exports.formatEntityName = formatEntityName;
+exports.normalizeKind = normalizeKind;
+exports.formatMeta = formatMeta;
+const types_1 = require("../shared/types");
+const inspect_format_primitives_1 = require("./inspect-format-primitives");
+const inspect_selector_kind_1 = require("./inspect-selector-kind");
+var inspect_selector_kind_2 = require("./inspect-selector-kind");
+Object.defineProperty(exports, "INSPECT_SELECTOR_KINDS", { enumerable: true, get: function () { return inspect_selector_kind_2.INSPECT_SELECTOR_KINDS; } });
+Object.defineProperty(exports, "isInspectSelectorKind", { enumerable: true, get: function () { return inspect_selector_kind_2.isInspectSelectorKind; } });
+function formatSymbolReferencesArray(rawSymbols, config) {
+    if (!Array.isArray(rawSymbols)) {
+        return [];
+    }
+    return rawSymbols
+        .filter(inspect_format_primitives_1.isObject)
+        .map((symbol) => formatSymbolReference(symbol, config))
+        .filter((selector) => selector !== "");
+}
+function formatSymbolReference(rawSymbol, config) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawSymbol)) {
+        return "";
+    }
+    if (typeof rawSymbol.selector === "string" && rawSymbol.selector.trim() !== "") {
+        return rawSymbol.selector;
+    }
+    const name = typeof rawSymbol.name === "string" ? rawSymbol.name : "";
+    const kind = typeof rawSymbol.kind === "string" ? normalizeKind(rawSymbol.kind) : null;
+    if (!name) {
+        return "";
+    }
+    if (kind === "constructor") {
+        return "constructor";
+    }
+    if (kind) {
+        return `${selectorAlias(kind, config)}${selectorSeparator(kind, config)}${name}`;
+    }
+    return name;
+}
+function formatEntityReference(rawSymbol, config) {
+    const name = formatEntityName(rawSymbol);
+    return name || formatSymbolReference(rawSymbol, config);
+}
+function formatEntityName(rawSymbol) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawSymbol)) {
+        return "";
+    }
+    return typeof rawSymbol.name === "string" ? rawSymbol.name : "";
+}
+function normalizeKind(kind) {
+    const normalized = kind.toLowerCase();
+    return (0, inspect_selector_kind_1.isInspectSelectorKind)(normalized) ? normalized : null;
+}
+function formatMeta(rawSymbol, _fallbackLineCount) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawSymbol) || !(0, inspect_format_primitives_1.isObject)(rawSymbol.range)) {
+        return "";
+    }
+    const start = readRangePosition(rawSymbol.range, "start");
+    const end = readRangePosition(rawSymbol.range, "end");
+    if (!start || !end) {
+        return "";
+    }
+    const startLine = start.line + 1;
+    const endLine = end.line + 1;
+    if (startLine === endLine) {
+        return `@${startLine}`;
+    }
+    return `@${startLine}..${endLine}`;
+}
+function selectorAlias(kind, config) {
+    return isEntityKind(kind) ? config.entityKindAliases[kind] : kind;
+}
+function selectorSeparator(kind, config) {
+    return isEntityKind(kind) ? config.selectorSeparator : ":";
+}
+function isEntityKind(kind) {
+    return types_1.ENTITY_KIND_IDS.includes(kind);
+}
+function readRangePosition(range, key) {
+    const value = range[key];
+    if (!(0, inspect_format_primitives_1.isObject)(value) || typeof value.line !== "number") {
+        return null;
+    }
+    return { line: value.line };
+}

package/dist/commands/inspect-topology.js

@@ -0,0 +1,435 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInspectTopologyRequest = isInspectTopologyRequest;
+exports.runInspectTopology = runInspectTopology;
+exports.formatTopologyBoundariesText = formatTopologyBoundariesText;
+exports.displayPath = displayPath;
+const path = __importStar(require("node:path"));
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const cache_1 = require("../topology/cache");
+const availability_1 = require("../topology/availability");
+const candidates_1 = require("../topology/candidates");
+const core_1 = require("../topology/core");
+const workspace_state_1 = require("../config/workspace-state");
+function isInspectTopologyRequest(restArgs, stdinPayload) {
+    if (stdinPayload !== undefined) {
+        return false;
+    }
+    return restArgs[0] === "topology" || restArgs[0] === "aliases" || restArgs[0] === "boundary" || restArgs[0] === "boundaries";
+}
+function runInspectTopology(cwd, restArgs, semanticContextPool) {
+    const op = restArgs[0];
+    if (op === "topology") {
+        return runInspectTopologySummary(cwd, restArgs);
+    }
+    if (op === "aliases") {
+        return runInspectTopologyAliases(cwd, restArgs);
+    }
+    if (op === "boundary") {
+        return runInspectTopologyBoundary(cwd, restArgs);
+    }
+    if (op === "boundaries") {
+        return runInspectTopologyBoundaries(cwd, restArgs, semanticContextPool);
+    }
+    throw new errors_1.CliError("INVALID_TOPOLOGY_INSPECT_OP", "Expected inspect topology, aliases, boundary, or boundaries.");
+}
+function runInspectTopologySummary(cwd, restArgs) {
+    const mode = readTopologyModeArg(restArgs);
+    const snapshot = (0, cache_1.getProjectTopologySnapshot)(cwd, mode);
+    if (!snapshot) {
+        return (0, agent_text_1.attachAgentText)({
+            operation: "inspect.topology",
+            mode: "off",
+            enabled: false
+        }, "topology: disabled");
+    }
+    const file = readFlagValue(restArgs, "--file") ?? readPositional(restArgs, 1);
+    if (file) {
+        const ownership = (0, core_1.describeTopologyFile)(snapshot, file);
+        return (0, agent_text_1.attachAgentText)({
+            operation: "inspect.topology.file",
+            mode: snapshot.mode,
+            ownership
+        }, formatTopologyFileText(ownership));
+    }
+    const cache = (0, cache_1.topologyCacheStatus)(cwd, mode);
+    return (0, agent_text_1.attachAgentText)({
+        operation: "inspect.topology",
+        mode: snapshot.mode,
+        root: snapshot.root,
+        tsconfigCount: snapshot.tsconfigs.length,
+        packageCount: snapshot.packages.length,
+        buildMs: snapshot.buildMs,
+        timings: snapshot.timings,
+        cache,
+        diagnostics: snapshot.diagnostics
+    }, formatTopologySummaryText(snapshot.tsconfigs.length, snapshot.packages.length, snapshot.timings, snapshot.diagnostics));
+}
+function runInspectTopologyAliases(cwd, restArgs) {
+    const snapshot = requireSnapshot(cwd, restArgs);
+    const from = readFlagValue(restArgs, "--from-file") ?? restArgs[1];
+    const to = readFlagValue(restArgs, "--to-file") ?? restArgs[2];
+    if (!from || !to) {
+        throw new errors_1.CliError("TOPOLOGY_ALIASES_USAGE", "Usage: aib inspect aliases <from-file> <to-file>");
+    }
+    const result = (0, core_1.resolveTopologyReachability)(snapshot, from, to);
+    return (0, agent_text_1.attachAgentText)({
+        operation: "inspect.aliases",
+        ...result
+    }, formatAliasesText(result));
+}
+function runInspectTopologyBoundary(cwd, restArgs) {
+    const snapshot = requireSnapshot(cwd, restArgs);
+    const target = readFlagValue(restArgs, "--path") ?? readPositional(restArgs, 1);
+    if (!target) {
+        throw new errors_1.CliError("TOPOLOGY_BOUNDARY_USAGE", "Usage: aib inspect boundary <path>");
+    }
+    const result = (0, core_1.buildBoundaryRelations)(snapshot, target);
+    return (0, agent_text_1.attachAgentText)({
+        operation: "inspect.boundary",
+        ...result
+    }, formatBoundaryText(result));
+}
+function runInspectTopologyBoundaries(cwd, restArgs, semanticContextPool) {
+    const state = (0, workspace_state_1.ensureWorkspaceState)(cwd);
+    const options = readTopologyInspectOptions(restArgs);
+    const defaultScope = !options.includeConfigExcluded && !options.includeDefaultExcluded;
+    let pooledSnapshotMs = null;
+    let snapshot;
+    if (semanticContextPool && defaultScope) {
+        const startedAt = Date.now();
+        snapshot = semanticContextPool.withWorkspaceProjectIndex((index) => index.topologySnapshot);
+        pooledSnapshotMs = Date.now() - startedAt;
+    }
+    else {
+        snapshot = (0, core_1.buildProjectTopologySnapshot)(state.root, {
+            scope: {
+                includeConfigExcluded: options.includeConfigExcluded,
+                includeDefaultExcluded: options.includeDefaultExcluded
+            }
+        });
+    }
+    const candidateSet = (0, candidates_1.generateTopologyCandidates)(snapshot);
+    const view = (0, availability_1.buildStructuralTopologyAvailabilityView)(snapshot, candidateSet);
+    if (pooledSnapshotMs !== null) {
+        view.timings.scopeMs = 0;
+        view.timings.catalogMs = pooledSnapshotMs;
+        view.timings.dependencyMs = 0;
+        view.timings.totalMs = pooledSnapshotMs + view.timings.candidateMs + view.timings.oracleMs + view.timings.availabilityMs;
+    }
+    return (0, agent_text_1.attachAgentText)({
+        operation: "inspect.boundaries",
+        root: snapshot.root,
+        formatOptions: {
+            timings: options.timings
+        },
+        ...(snapshot.scope ? { scope: snapshot.scope } : {}),
+        ...view
+    }, formatTopologyBoundariesText(view, options));
+}
+function requireSnapshot(cwd, restArgs) {
+    const snapshot = (0, cache_1.getProjectTopologySnapshot)(cwd, readTopologyModeArg(restArgs));
+    if (!snapshot) {
+        throw new errors_1.CliError("TOPOLOGY_DISABLED", "Project topology is disabled by AIB_TOPOLOGY=off.");
+    }
+    return snapshot;
+}
+function readTopologyModeArg(args) {
+    const value = readFlagValue(args, "--topology");
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "off" || value === "lazy") {
+        return value;
+    }
+    throw new errors_1.CliError("TOPOLOGY_MODE_INVALID", "inspect topology --topology expects off or lazy.");
+}
+function readTopologyInspectOptions(args) {
+    return {
+        includeConfigExcluded: args.includes("+nec") || args.includes("--no-config-exclude"),
+        includeDefaultExcluded: args.includes("+ned") || args.includes("--no-default-exclude"),
+        timings: args.includes("--timings") || args.includes("--debug-timings") || args.includes("--topology-timings")
+    };
+}
+function formatTopologySummaryText(tsconfigCount, packageCount, timings, diagnostics) {
+    const lines = [
+        "inspect.topology",
+        `${tsconfigCount} tsconfigs, ${packageCount} packages`,
+        `snapshot: built in ${timings.totalMs}ms`,
+        `timings: tsconfig ${timings.tsconfigMs}ms, packages ${timings.packageMs}ms`
+    ];
+    appendDiagnostics(lines, diagnostics);
+    return lines.join("\n");
+}
+function formatTopologyFileText(ownership) {
+    const lines = [
+        `inspect.topology ${ownership.file}`,
+        ownership.tsconfig ? `tsconfig: ${ownership.tsconfig}` : "tsconfig: none",
+        ownership.packageName
+            ? `package: ${ownership.packageName} (${ownership.packageRoot ?? ""})`
+            : ownership.packageRoot
+                ? `package: ${ownership.packageRoot}`
+                : "package: none"
+    ];
+    appendDiagnostics(lines, ownership.diagnostics);
+    return lines.join("\n");
+}
+function formatAliasesText(result) {
+    const lines = [
+        `inspect.aliases ${result.from} -> ${result.to}`,
+        `reachable: ${result.reachable ? "yes" : "no"}`
+    ];
+    const valid = result.candidates.filter((candidate) => candidate.valid);
+    const invalid = result.candidates.filter((candidate) => !candidate.valid);
+    if (valid.length > 0) {
+        lines.push("valid specifiers:");
+        for (const candidate of valid) {
+            lines.push(`- ${candidate.specifier} (${candidate.kind})`);
+        }
+    }
+    if (invalid.length > 0) {
+        lines.push("invalid/risky candidates:");
+        for (const candidate of invalid.slice(0, 6)) {
+            lines.push(`- ${candidate.specifier} (${candidate.kind}): ${candidate.reason}`);
+        }
+    }
+    appendDiagnostics(lines, result.diagnostics);
+    return lines.join("\n");
+}
+function formatBoundaryText(result) {
+    const lines = [
+        `inspect.boundary ${result.boundary}`,
+        result.packageName ? `package: ${result.packageName}` : "package: none"
+    ];
+    appendRelations(lines, "can import", result.canImport);
+    appendRelations(lines, "can be imported by", result.canBeImportedBy);
+    appendDiagnostics(lines, result.diagnostics);
+    return lines.join("\n");
+}
+function formatTopologyBoundariesText(view, options = {}) {
+    const relationCount = countConfirmedRelations(view);
+    const lines = [
+        "inspect.boundaries",
+        `${view.boundaries.length} boundaries, ${relationCount} ${view.validationMode === "structural" ? "configured" : "confirmed"} relations`
+    ];
+    appendAnalysisSummary(lines, view, relationCount);
+    if (view.boundaries.length > 0) {
+        lines.push("", "boundaries", "package-name                      path");
+        const boundaries = view.boundaries.slice(0, 32);
+        for (const boundary of boundaries) {
+            lines.push(`${pad(boundary.packageName ?? "-", 33)} ${boundary.path}`);
+        }
+        if (view.boundaries.length > boundaries.length) {
+            lines.push(`+ ${view.boundaries.length - boundaries.length} more boundaries`);
+        }
+    }
+    if (view.aliasScopes.length > 0) {
+        lines.push("", "aliases");
+        for (const scope of view.aliasScopes) {
+            lines.push(`${scope.scope}:`);
+            for (const entry of scope.paths.slice(0, 24)) {
+                lines.push(`  ${pad(entry.pattern, 24)} -> ${entry.targets.join(" ")}`);
+            }
+            if (scope.paths.length > 24) {
+                lines.push(`  + ${scope.paths.length - 24} more`);
+            }
+        }
+    }
+    if (view.providers.length > 0) {
+        lines.push("", view.validationMode === "structural" ? "configured availability" : "ts availability");
+        const providers = view.providers.slice(0, 24);
+        for (const provider of providers) {
+            lines.push(`${provider.provider.path} available in:`);
+            const consumers = provider.consumers.slice(0, 12);
+            for (const consumer of consumers) {
+                lines.push(`  ${pad(consumer.boundary, 24)} via ${consumer.specifiers.slice(0, 3).join(", ")}`);
+            }
+            if (provider.consumers.length > consumers.length) {
+                lines.push(`  + ${provider.consumers.length - consumers.length} more consumers`);
+            }
+        }
+        if (view.providers.length > providers.length) {
+            lines.push(`+ ${view.providers.length - providers.length} more providers`);
+        }
+    }
+    else if (view.boundaries.length > 0) {
+        lines.push("", view.validationMode === "structural" ? "configured availability" : "ts availability");
+        lines.push(view.validationMode === "structural"
+            ? "no configured cross-boundary availability"
+            : isTrustedZeroAvailability(view) ? "no cross-boundary availability under current TypeScript setup" : "no confirmed cross-boundary availability");
+    }
+    if (view.notExposed.length > 0 && relationCount > 0) {
+        lines.push("", "not exposed to other boundaries:");
+        const notExposed = view.notExposed.slice(0, 32);
+        for (const boundary of notExposed) {
+            lines.push(`  ${boundary.path}`);
+        }
+        if (view.notExposed.length > notExposed.length) {
+            lines.push(`  + ${view.notExposed.length - notExposed.length} more`);
+        }
+    }
+    if (options.timings === true) {
+        appendResolutionDetails(lines, view);
+        lines.push("", "timings:", `  scope ${view.timings.scopeMs}ms`, `  catalog ${view.timings.catalogMs}ms`, `  dependency ${view.timings.dependencyMs}ms`, `  candidates ${view.timings.candidateMs}ms (${view.debug.candidates} candidates)`, `  oracle ${view.timings.oracleMs}ms (${view.debug.oracleGroups.length} groups)`, `  availability ${view.timings.availabilityMs}ms`, `  total ${view.timings.totalMs}ms`);
+        if (view.debug.candidateSkipped.length > 0) {
+            lines.push("skipped:");
+            for (const skipped of view.debug.candidateSkipped.slice(0, 8)) {
+                lines.push(`  ${skipped.reason}: ${skipped.count}`);
+            }
+        }
+        const slowest = [...view.debug.oracleGroups].sort((left, right) => right.timings.totalMs - left.timings.totalMs).slice(0, 5);
+        if (slowest.length > 0) {
+            lines.push("slowest oracle groups:");
+            for (const group of slowest) {
+                lines.push(`  ${group.tsconfig}: ${group.timings.totalMs}ms, ${group.candidates} candidates`);
+            }
+        }
+    }
+    if (options.timings === true) {
+        appendDiagnostics(lines, view.diagnostics);
+    }
+    return lines.join("\n");
+}
+function countConfirmedRelations(view) {
+    return view.providers.reduce((sum, provider) => sum + provider.consumers.length, 0);
+}
+function appendAnalysisSummary(lines, view, relationCount) {
+    if (view.validationMode === "structural") {
+        return;
+    }
+    const health = view.resolutionHealth;
+    const deps = health.dependencySnapshot;
+    const hasInstallArtifacts = deps.installArtifacts.nodeModules || deps.installArtifacts.pnp;
+    const topReasons = new Set(health.unconfirmedReasons.map((item) => item.reason));
+    const hasPackageEntryIssue = health.unconfirmedReasons.some((item) => item.reason === "package-dependency-build-output-missing" ||
+        item.reason === "package-dependency-source-condition-not-enabled" ||
+        item.reason === "package-dependency-entry-target-missing" ||
+        item.reason === "package-dependency-no-entry-targets" ||
+        item.reason === "package-dependency-unresolved");
+    const notes = [];
+    if (relationCount === 0 && health.candidates.total > 0) {
+        if (!hasInstallArtifacts && deps.lockfiles.length > 0) {
+            notes.push("dependencies/build outputs are not available; zero confirmed relations does not prove isolation");
+        }
+        else if (hasPackageEntryIssue && deps.state !== "unknown") {
+            notes.push("package entries need build outputs or enabled export conditions; zero confirmed relations may be incomplete");
+        }
+        else if (deps.state !== "unknown" && (health.candidates.unresolved > 0 || topReasons.has("tsconfig-path-unresolved"))) {
+            notes.push("some configured aliases do not resolve; zero confirmed relations may be incomplete");
+        }
+    }
+    else if (relationCount > 0 && health.candidates.bySource.packageDependency > 0 && deps.state === "absent" && !hasInstallArtifacts) {
+        notes.push("package-name checks are incomplete because dependency artifacts are missing");
+    }
+    if (notes.length === 0) {
+        return;
+    }
+    lines.push("", "analysis");
+    for (const note of notes.slice(0, 2)) {
+        lines.push(`note: ${note}`);
+    }
+}
+function isTrustedZeroAvailability(view) {
+    const health = view.resolutionHealth;
+    const deps = health.dependencySnapshot;
+    return (health.confidence === "complete" &&
+        deps.state === "present" &&
+        health.candidates.unresolved === 0 &&
+        health.candidates.projectInvalid === 0 &&
+        health.candidates.unknown === 0 &&
+        health.candidates.resolutionOnly === 0);
+}
+function appendResolutionDetails(lines, view) {
+    if (view.validationMode === "structural") {
+        lines.push("", "validation", "mode: structural", "oracle: not run", "programs: 0");
+        return;
+    }
+    const health = view.resolutionHealth;
+    const deps = health.dependencySnapshot;
+    const manager = deps.packageManager ? `, ${deps.packageManager}` : "";
+    lines.push("", "resolution", `dependencies: ${deps.state}${manager}`, `confirmed: ${health.candidates.confirmed}/${health.candidates.total} candidates`);
+    const unresolved = [
+        health.candidates.resolutionOnly > 0 ? `${health.candidates.resolutionOnly} not project-validated` : "",
+        health.candidates.unresolved > 0 ? `${health.candidates.unresolved} unresolved` : "",
+        health.candidates.projectInvalid > 0 ? `${health.candidates.projectInvalid} project-invalid` : ""
+    ].filter(Boolean);
+    if (unresolved.length > 0) {
+        lines.push(`incomplete: ${unresolved.join(", ")}`);
+    }
+    if (health.unconfirmedReasons.length > 0) {
+        lines.push(`top reason: ${health.unconfirmedReasons.slice(0, 3).map((item) => `${item.reason}=${item.count}`).join(", ")}`);
+    }
+    if (health.confidence !== "complete" && health.notes.length > 0) {
+        lines.push(`note: ${health.notes[0]}`);
+    }
+}
+function appendRelations(lines, title, relations) {
+    if (relations.length === 0) {
+        return;
+    }
+    lines.push(`${title}:`);
+    for (const relation of relations.slice(0, 12)) {
+        const status = relation.reachable ? "yes" : "no";
+        lines.push(`- ${relation.from} -> ${relation.to}: ${status} (${relation.reasons.join("; ")})`);
+    }
+    if (relations.length > 12) {
+        lines.push(`+ ${relations.length - 12} more`);
+    }
+}
+function appendDiagnostics(lines, diagnostics) {
+    if (diagnostics.length === 0) {
+        return;
+    }
+    lines.push("diagnostics:");
+    for (const diagnostic of diagnostics.slice(0, 8)) {
+        lines.push(`- ${diagnostic.code}: ${diagnostic.file ? `${diagnostic.file}: ` : ""}${diagnostic.message}`);
+    }
+}
+function pad(value, length) {
+    return value.length >= length ? value : `${value}${" ".repeat(length - value.length)}`;
+}
+function readFlagValue(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function readPositional(args, index) {
+    const value = args[index];
+    return value && !value.startsWith("-") ? value : undefined;
+}
+function displayPath(cwd, file) {
+    return path.relative(cwd, file).replace(/\\/g, "/");
+}