@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/commands/init-skill-usage.js

@@ -1,3 +1,92 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.runInitSkillUsage=I;const f=require("./shared"),C=require("../shared/protocol");function a(e,n,t){const s=e[n];return s&&s.trim().length>0?s.trim():t}function w(e,n,t,s){const i=a(n,"ping","ping"),r=a(n,"printConfig","printConfig"),c=a(n,"inspect","inspect"),l=a(n,"imports","imports"),p=a(n,"move","move"),u=a(n,"rename","rename"),$=t.class??"c",d=t.interface??"i",m=t.function??"f",g=t.type??"t",o=s||"-";return["# aib skill usage","","Используй этот CLI, когда нужно взаимодействовать с живым IDE instance, а не читать код только через shell.","","## Базовая диагностика","",`- \`${e} ${i}\``,`- \`${e} ${r}\``,`- \`${e} listInstances\``,"","## Полезные операции","",`- Показать сущности файла: \`${e} ${c} file src/foo.ts\``,`- Найти importers файла/директории: \`${e} ${l} importers src/utils\``,`- Найти unused imports: \`${e} ${l} unused src/foo.ts\``,"","## Selector DSL","","Используй compact selectors для сущностей, когда это уместно.","",`- class: \`${$}${o}MyClass\``,`- interface: \`${d}${o}IMyClass\``,`- function: \`${m}${o}helper\``,`- type: \`${g}${o}UserShape\``,"","Если имя в рамках файла уникально, можно передавать selector без kind. Если возникает ambiguity, используй kind-prefix.","","## Move","","Preview:","","```powershell","@'",`{"sourceFile":"src/foo.ts","targetFile":"src/bar.ts","entities":["${$}${o}MyClass","${d}${o}IMyClass","${m}${o}helper"]}`,`'@ | ${e} ${p} toFile preview --stdin`,"```","","Execute:","","```powershell",`${e} ${p} toFile apply <previewId>`,"```","","## Rename","","```powershell","@'",'{"sourceFile":"src/foo.ts","renames":[{"entity":"MyClass","newName":"RenamedClass"},{"entity":"helper","newName":"renamedHelper"}]}',`'@ | ${e} ${u} preview --stdin`,`${e} ${u} apply <previewId>`,"```","","## Notes","","- Запускай CLI из директории проекта или передавай `--cwd`, чтобы корректно выбрался нужный IDE instance.","- Если открыто несколько IDE окон, сначала посмотри `listInstances` или используй `--instance`."].join(`
-`)}function y(e,n,t,s){return["# aib skill usage diagnostic","",`cliName: ${e}`,`selectorSeparator: ${JSON.stringify(s)}`,`methodAliases: ${JSON.stringify(n)}`,`entityKindAliases: ${JSON.stringify(t)}`,"","Diagnostic mode is intentionally compact. Full production output is in buildSkillMarkdownProd."].join(`
-`)}async function I(e){const{cwd:n,resolveOptions:t={},cliName:s="aib"}=e,i=await(0,f.resolveCompatibleTargetInstance)(n,C.CLI_COMMAND_IDS.initSkillUsage,t),r=await(0,f.fetchEffectiveConfig)(i.entry),c=y(s,r.methodAliases,r.entityKindAliases,r.selectorSeparator);return{ok:!0,selectedInstance:{instanceId:i.entry.instanceId,reason:i.reason,matchedWorkspace:i.matchedWorkspace,port:i.entry.port},cliName:s,effectiveConfig:r,markdown:c}}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInitSkillUsage = runInitSkillUsage;
+const resolve_1 = require("../config/resolve");
+function getCommandName(methodAliases, canonicalName, fallbackName) {
+    const aliasName = methodAliases[canonicalName];
+    return aliasName && aliasName.trim().length > 0 ? aliasName.trim() : fallbackName;
+}
+function buildSkillMarkdownProd(cliName, methodAliases, entityKindAliases, selectorSeparator) {
+    const printConfigCommand = getCommandName(methodAliases, "printConfig", "printConfig");
+    const inspectCommand = getCommandName(methodAliases, "inspect", "inspect");
+    const importsCommand = getCommandName(methodAliases, "imports", "imports");
+    const mutateCommand = getCommandName(methodAliases, "mutate", "mutate");
+    const classAlias = entityKindAliases.class ?? "c";
+    const interfaceAlias = entityKindAliases.interface ?? "i";
+    const functionAlias = entityKindAliases.function ?? "f";
+    const typeAlias = entityKindAliases.type ?? "t";
+    const join = selectorSeparator || "-";
+    return [
+        "# aib skill usage",
+        "",
+        "Используй этот CLI для анализа и изменения TypeScript/JavaScript workspace.",
+        "",
+        "## Базовая диагностика",
+        "",
+        `- \`${cliName} ${printConfigCommand}\``,
+        `- \`${cliName} doctor\``,
+        "",
+        "## Полезные операции",
+        "",
+        `- Показать сущности файла: \`${cliName} ${inspectCommand} file src/foo.ts\``,
+        `- Найти importers файла/директории: \`${cliName} ${importsCommand} importers src/utils\``,
+        `- Найти unused imports: \`${cliName} ${importsCommand} unused src/foo.ts\``,
+        "",
+        "## Selector DSL",
+        "",
+        "Используй compact selectors для сущностей, когда это уместно.",
+        "",
+        `- class: \`${classAlias}${join}MyClass\``,
+        `- interface: \`${interfaceAlias}${join}IMyClass\``,
+        `- function: \`${functionAlias}${join}helper\``,
+        `- type: \`${typeAlias}${join}UserShape\``,
+        "",
+        "Если имя в рамках файла уникально, можно передавать selector без kind. Если возникает ambiguity, используй kind-prefix.",
+        "",
+        "## Mutate",
+        "",
+        "Preview:",
+        "",
+        "```powershell",
+        `@'`,
+        "@source src/foo.ts",
+        `move src/bar.ts: ${classAlias}${join}MyClass ${interfaceAlias}${join}IMyClass ${functionAlias}${join}helper`,
+        "rename OldName->NewName",
+        `'@ | ${cliName} ${mutateCommand} preview --stdin`,
+        "```",
+        "",
+        "Apply:",
+        "",
+        "```powershell",
+        `${cliName} ${mutateCommand} apply <previewId>`,
+        "```",
+        "",
+        "## Notes",
+        "",
+        "- Запускай CLI из директории проекта или передавай `--cwd`, чтобы корректно определился workspace.",
+        "- Для долгой серии команд создай CLI session один раз и переиспользуй её."
+    ].join("\n");
+}
+function buildSkillMarkdown(cliName, methodAliases, entityKindAliases, selectorSeparator) {
+    return [
+        "# aib skill usage diagnostic",
+        "",
+        `cliName: ${cliName}`,
+        `selectorSeparator: ${JSON.stringify(selectorSeparator)}`,
+        `methodAliases: ${JSON.stringify(methodAliases)}`,
+        `entityKindAliases: ${JSON.stringify(entityKindAliases)}`,
+        "",
+        "Diagnostic mode is intentionally compact. Full production output is in buildSkillMarkdownProd."
+    ].join("\n");
+}
+async function runInitSkillUsage(options) {
+    const { cliName = "aib" } = options;
+    const effectiveConfig = (0, resolve_1.resolveCliConfig)(null);
+    const markdown = buildSkillMarkdown(cliName, effectiveConfig.methodAliases, effectiveConfig.entityKindAliases, effectiveConfig.selectorSeparator);
+    return {
+        ok: true,
+        cliName,
+        effectiveConfig,
+        markdown
+    };
+}

package/dist/commands/init-workspace.js

@@ -1 +1,30 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.runInitWorkspace=_;const i=require("../shared/errors"),s=require("../shared/agent-text"),c=require("../config/workspace-root"),u=require("./config-output"),a=require("./config-command");function _(e,r){const t=p(r),n=(0,c.initWorkspaceRoot)(e,t);return(0,s.attachAgentText)(n,(0,u.formatInitText)((0,a.readConfigTextInput)(e),String(n.status??"created")))}function p(e){const r={};for(let t=0;t<e.length;t+=1){if(e[t]==="--session-dir"){const o=e[t+1];if(!o||o.startsWith("--"))throw new i.CliError("MISSING_FLAG_VALUE","Expected a value after --session-dir.");r.sessionDir=o,t+=1;continue}throw new i.CliError("INIT_USAGE","Usage: aib init [--session-dir .tmp/aib]")}return r}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInitWorkspace = runInitWorkspace;
+const errors_1 = require("../shared/errors");
+const agent_text_1 = require("../shared/agent-text");
+const workspace_root_1 = require("../config/workspace-root");
+const config_output_1 = require("./config-output");
+const config_command_1 = require("./config-command");
+function runInitWorkspace(cwd, restArgs) {
+    const options = parseInitArgs(restArgs);
+    const result = (0, workspace_root_1.initWorkspaceRoot)(cwd, options);
+    return (0, agent_text_1.attachAgentText)(result, (0, config_output_1.formatInitText)((0, config_command_1.readConfigTextInput)(cwd), String(result.status ?? "created")));
+}
+function parseInitArgs(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (current === "--session-dir") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("--")) {
+                throw new errors_1.CliError("MISSING_FLAG_VALUE", "Expected a value after --session-dir.");
+            }
+            options.sessionDir = next;
+            index += 1;
+            continue;
+        }
+        throw new errors_1.CliError("INIT_USAGE", "Usage: aib init [--session-dir .tmp/aib]");
+    }
+    return options;
+}

package/dist/commands/inspect-alias-candidates.js

@@ -0,0 +1,413 @@
+"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.isInspectAliasCandidatesRequest = isInspectAliasCandidatesRequest;
+exports.runInspectAliasCandidates = runInspectAliasCandidates;
+exports.buildInspectAliasCandidatesResult = buildInspectAliasCandidatesResult;
+exports.formatAliasCandidatesResponse = formatAliasCandidatesResponse;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const path_display_1 = require("../config/path-display");
+const session_workspace_1 = require("./session-workspace");
+const analyze_1 = require("../alias-advisor/analyze");
+const lexical_1 = require("../alias-advisor/lexical");
+const DEFAULT_LIMIT = 12;
+const DEFAULT_MIN_IMPORTS = 2;
+const DEFAULT_MIN_FILES = 1;
+function isInspectAliasCandidatesRequest(restArgs, stdinPayload) {
+    if (restArgs[0] === "aliasCandidates" || restArgs[0] === "alias-candidates") {
+        return true;
+    }
+    if (!restArgs.includes("--stdin") || !isObject(stdinPayload)) {
+        return false;
+    }
+    const requests = expandAliasPayloadRequests(stdinPayload);
+    return requests.length > 0 && requests.some((request) => isAliasCandidatesOp(readString(request.op)));
+}
+function runInspectAliasCandidates(cwd, restArgs, stdinPayload) {
+    const aliases = (0, path_display_1.buildDisplayPathAliases)(cwd, (0, session_workspace_1.readEffectiveSessionPathAliases)(cwd));
+    const requests = buildAliasCandidateRequests(cwd, restArgs, stdinPayload, aliases);
+    const results = requests.map((request) => runAliasCandidateRequest(cwd, request, aliases));
+    const response = buildAliasCandidateResponse(results);
+    return (0, agent_text_1.attachAgentText)(response, formatAliasCandidatesResponse(response));
+}
+function buildInspectAliasCandidatesResult(cwd, input) {
+    const aliases = (0, path_display_1.buildDisplayPathAliases)(cwd, (0, session_workspace_1.readEffectiveSessionPathAliases)(cwd));
+    const partial = {
+        scope: input.scope,
+        include: input.include ?? [],
+        exclude: input.exclude ?? []
+    };
+    if (input.displayScope !== undefined) {
+        partial.displayScope = input.displayScope;
+    }
+    if (input.limit !== undefined) {
+        partial.limit = input.limit;
+    }
+    if (input.minImports !== undefined) {
+        partial.minImports = input.minImports;
+    }
+    if (input.minFiles !== undefined) {
+        partial.minFiles = input.minFiles;
+    }
+    if (input.detail !== undefined) {
+        partial.detail = input.detail;
+    }
+    if (input.candidate !== undefined) {
+        partial.candidate = input.candidate;
+    }
+    const request = finalizeAliasCandidateRequest(cwd, partial, aliases);
+    return runAliasCandidateRequest(cwd, request, aliases);
+}
+function formatAliasCandidatesResponse(response) {
+    if (Array.isArray(response.results)) {
+        const chunks = response.results
+            .filter(isObject)
+            .map((item) => formatAliasCandidatesResponse(item))
+            .filter((item) => typeof item === "string" && item.length > 0);
+        return chunks.length > 0 ? chunks.join("\n\n") : null;
+    }
+    if (response.ok === false) {
+        return [`alias candidates errors:`, `${String(response.scope ?? "")}: ${String(response.error ?? "failed")}`].join("\n");
+    }
+    const scope = readString(response.scope) ?? "";
+    const lines = [`alias advisor ${scope}`.trim()];
+    lines.push(`mode: ${readString(response.mode) ?? "topology-aware-advisor"}`);
+    const ranking = isObject(response.ranking) ? response.ranking : {};
+    const estimator = isObject(ranking.estimatorProfile) ? ranking.estimatorProfile : {};
+    lines.push(`ranking: ${readString(ranking.policyVersion) ?? "alias-ranking-v2-text-primary"}; exact text primary; ${readString(estimator.id) ?? "path-lexical-v1"} secondary, not billing`);
+    const evidenceFilter = isObject(response.evidenceFilter) ? response.evidenceFilter : {};
+    const decisionPolicy = isObject(response.decisionPolicy) ? response.decisionPolicy : {};
+    lines.push(`policy: evidence >=${readNumber(evidenceFilter.minImports)} imports/${readNumber(evidenceFilter.minFiles)} files; decision >=${readNumber(decisionPolicy.minImports)}/${readNumber(decisionPolicy.minFiles)}, exact text net >=${readNumber(decisionPolicy.materialNetCharacters)} chars`);
+    lines.push(`analyzed: ${readNumber(response.analyzedSpecifiers)} import specifiers, ${readNumber(response.analyzedFiles)} files`);
+    const topology = isObject(response.topology) ? response.topology : {};
+    lines.push(topology.available === true
+        ? `topology: ${readNumber(topology.tsconfigs)} tsconfigs, ${readNumber(topology.packages)} packages, dependencies ${readString(topology.dependencyState) ?? "unknown"}`
+        : "topology: unavailable; evidence is fail-closed");
+    const timings = isObject(response.timings) ? response.timings : {};
+    if (typeof timings.totalMs === "number") {
+        lines.push(`time: ${timings.totalMs}ms (lexical ${readNumber(timings.lexicalMs)}, topology ${readNumber(timings.topologyMs)}, resolution ${readNumber(timings.resolutionMs)})`);
+    }
+    const candidates = readObjectArray(response.candidates);
+    if (candidates.length === 0) {
+        lines.push("");
+        lines.push("no alias evidence matched thresholds");
+        lines.push("recommendation: none; current aliases are adequate under the provisional policy");
+        return lines.join("\n");
+    }
+    const categoryCounts = isObject(ranking.categoryCounts) ? ranking.categoryCounts : {};
+    if (readNumber(categoryCounts.recommended) === 0) {
+        lines.push(readNumber(categoryCounts.review) + readNumber(categoryCounts.optional) > 0
+            ? "recommendation: no confident recommendation; review candidates available"
+            : "recommendation: none; no eligible candidate passed M2 gates");
+    }
+    const outputLimit = response.candidate ? 6 : 5;
+    const displayedCandidates = candidates.slice(0, outputLimit);
+    const groups = [
+        ["recommended", displayedCandidates.filter((candidate) => readRankingCategory(candidate) === "recommended")],
+        ["review", displayedCandidates.filter((candidate) => readRankingCategory(candidate) === "review")],
+        ["optional", displayedCandidates.filter((candidate) => readRankingCategory(candidate) === "optional")],
+        ["rejected evidence", displayedCandidates.filter((candidate) => readRankingCategory(candidate) === "rejected")]
+    ];
+    for (const [label, items] of groups) {
+        if (items.length === 0) {
+            continue;
+        }
+        lines.push("");
+        lines.push(`${label}:`);
+        for (const candidate of items) {
+            appendAdvisorCandidate(lines, candidate, response.detail === "examples" || Boolean(response.candidate));
+        }
+    }
+    const hidden = readNumber(response.hiddenCandidates) + Math.max(0, candidates.length - displayedCandidates.length);
+    if (hidden > 0) {
+        lines.push("");
+        lines.push(`+ ${hidden} more candidates available in JSON`);
+    }
+    return lines.join("\n");
+}
+function buildAliasCandidateRequests(cwd, restArgs, stdinPayload, aliases) {
+    if (restArgs[0] === "aliasCandidates" || restArgs[0] === "alias-candidates") {
+        return aliasRequestsFromArgs(cwd, restArgs.slice(1), aliases);
+    }
+    if (!restArgs.includes("--stdin") || !isObject(stdinPayload)) {
+        throw aliasScopeRequiredError();
+    }
+    const rawRequests = expandAliasPayloadRequests(stdinPayload);
+    if (rawRequests.some((request) => !isAliasCandidatesOp(readString(request.op)))) {
+        throw new errors_1.CliError("INSPECT_ALIAS_CANDIDATES_MIXED_BATCH_UNSUPPORTED", "inspect aliasCandidates --stdin expects only aliasCandidates requests.");
+    }
+    return rawRequests.map((request, index) => aliasRequestFromObject(cwd, request, index, aliases));
+}
+function aliasRequestsFromArgs(cwd, args, aliases) {
+    const positionals = args.filter((arg) => !arg.startsWith("--") && !isFlagValue(args, arg));
+    if (positionals.length === 0) {
+        throw aliasScopeRequiredError();
+    }
+    const options = {
+        limit: readPositiveIntegerFlag(args, "--limit"),
+        minImports: readPositiveIntegerFlag(args, "--min-imports") ?? readPositiveIntegerFlag(args, "--minImports"),
+        minFiles: readPositiveIntegerFlag(args, "--min-files") ?? readPositiveIntegerFlag(args, "--minFiles"),
+        detail: readFlagValue(args, "--detail"),
+        candidate: readFlagValue(args, "--candidate"),
+        include: readFlagValues(args, "--include"),
+        exclude: readFlagValues(args, "--exclude")
+    };
+    return positionals.map((scope) => finalizeAliasCandidateRequest(cwd, {
+        scope,
+        ...options
+    }, aliases));
+}
+function aliasRequestFromObject(cwd, raw, index, aliases) {
+    const scope = readString(raw.scope) ?? readString(raw.dir) ?? readString(raw.directory);
+    if (!scope) {
+        throw new errors_1.CliError("INSPECT_ALIAS_CANDIDATES_SCOPE_REQUIRED", `Inspect aliasCandidates request at index ${index} expects a directory scope.`);
+    }
+    return finalizeAliasCandidateRequest(cwd, {
+        scope,
+        limit: readPositiveInteger(raw.limit),
+        minImports: readPositiveInteger(raw.minImports) ?? readPositiveInteger(raw.min_imports),
+        minFiles: readPositiveInteger(raw.minFiles) ?? readPositiveInteger(raw.min_files),
+        detail: readString(raw.detail),
+        candidate: readString(raw.candidate),
+        include: readStringArray(raw.include) ?? readStringArray(raw.only) ?? [],
+        exclude: readStringArray(raw.exclude) ?? readStringArray(raw.excludes) ?? []
+    }, aliases);
+}
+function finalizeAliasCandidateRequest(cwd, partial, aliases) {
+    const scope = resolveCliPath(cwd, partial.scope);
+    const detail = partial.detail === "examples" ? "examples" : "sum";
+    return {
+        scope,
+        displayScope: partial.displayScope ?? (0, path_display_1.compactDisplayPath)(cwd, scope, aliases),
+        limit: partial.limit ?? DEFAULT_LIMIT,
+        minImports: partial.minImports ?? DEFAULT_MIN_IMPORTS,
+        minFiles: partial.minFiles ?? DEFAULT_MIN_FILES,
+        detail,
+        ...(partial.candidate ? { candidate: partial.candidate } : {}),
+        include: partial.include,
+        exclude: partial.exclude
+    };
+}
+function runAliasCandidateRequest(cwd, request, aliases) {
+    const scopeStat = safeStat(request.scope);
+    if (!scopeStat) {
+        return aliasErrorResult(request, "pathNotFound", "path was not found");
+    }
+    if (!scopeStat.isDirectory()) {
+        return aliasErrorResult(request, "notDirectory", "scope is not a directory");
+    }
+    const lexical = (0, lexical_1.collectAliasLexicalEvidence)({
+        cwd,
+        scope: request.scope,
+        aliases,
+        include: request.include,
+        exclude: request.exclude,
+        minImports: request.minImports,
+        minFiles: request.minFiles
+    });
+    return JSON.parse(JSON.stringify((0, analyze_1.analyzeAliasAdvisor)({
+        cwd,
+        request: {
+            ...request,
+            displayScope: request.displayScope ?? (0, path_display_1.compactDisplayPath)(cwd, request.scope, aliases)
+        },
+        analyzedFiles: lexical.files.length,
+        analyzedSpecifiers: lexical.occurrences.length,
+        lexicalEvidence: lexical.evidence,
+        lexicalMs: lexical.elapsedMs
+    })));
+}
+function appendAdvisorCandidate(lines, candidate, showExamples) {
+    const alias = readString(candidate.alias) ?? "<alias>";
+    const target = readString(candidate.targetPattern) ?? "unresolved target";
+    lines.push(`- ${alias} -> ${target}`);
+    const coverage = isObject(candidate.coverage) ? candidate.coverage : {};
+    lines.push(`  coverage: ${readNumber(coverage.imports)} imports, ${readNumber(coverage.files)} files, ${readNumber(coverage.resolvedInternal)} internal resolved`);
+    const tokenCost = isObject(candidate.tokenCost) ? candidate.tokenCost : {};
+    const oneTime = isObject(tokenCost.oneTimeConfigTokenCost) ? tokenCost.oneTimeConfigTokenCost : {};
+    const payback = typeof tokenCost.paybackOccurrences === "number" ? String(tokenCost.paybackOccurrences) : "n/a";
+    lines.push(`  tokens est: source ${formatSigned(readNumber(tokenCost.sourceTokenDelta))}, config -${readNumber(oneTime.total)}, net ${formatSigned(readNumber(tokenCost.netTokenSaving))}, payback ${payback} imports`);
+    const overlap = isObject(candidate.overlap) ? candidate.overlap : {};
+    const dominatedBy = readString(overlap.dominatedBy);
+    lines.push(`  overlap: ${readNumber(overlap.exclusiveImports)} exclusive, ${readNumber(overlap.marginalImports)} marginal, marginal net ${formatSigned(readNumber(overlap.marginalTokenSaving))}${dominatedBy ? `, dominated by ${dominatedBy}` : ""}`);
+    const conflicts = readObjectArray(candidate.conflicts);
+    for (const conflict of conflicts.slice(0, showExamples ? 5 : 2)) {
+        lines.push(`  conflict ${readString(conflict.code) ?? "unknown"}: ${readString(conflict.message) ?? "blocked"}`);
+    }
+    if (showExamples) {
+        const configs = readObjectArray(candidate.applicableTsconfigs);
+        if (configs.length > 0) {
+            lines.push(`  tsconfigs: ${configs.map((item) => readString(item.tsconfig)).filter(Boolean).join(", ")}`);
+        }
+    }
+    if (!showExamples) {
+        return;
+    }
+    const examples = readObjectArray(candidate.examples);
+    if (examples.length === 0) {
+        return;
+    }
+    lines.push("  examples:");
+    for (const example of examples.slice(0, 6)) {
+        const from = readString(example.from) ?? "";
+        const to = readString(example.to);
+        lines.push(`  ${readString(example.importer) ?? ""}`);
+        lines.push(`    "${from}"${to ? ` -> "${to}"` : ""}`);
+    }
+}
+function readRankingCategory(candidate) {
+    return isObject(candidate.ranking) ? readString(candidate.ranking.category) ?? "rejected" : "rejected";
+}
+function formatSigned(value) {
+    return value > 0 ? `+${value}` : String(value);
+}
+function buildAliasCandidateResponse(results) {
+    const failures = results.filter(isAliasCandidateErrorResult);
+    const successes = results.filter((result) => !isAliasCandidateErrorResult(result));
+    if (results.length === 1 && failures.length === 0) {
+        return successes[0];
+    }
+    if (results.length === 1 && failures.length === 1) {
+        return failures[0];
+    }
+    return {
+        ...(successes.length === 0 ? { ok: false } : { ok: failures.length === 0 }),
+        op: "aliasCandidates",
+        results
+    };
+}
+function aliasErrorResult(request, errorKind, error) {
+    return {
+        ok: false,
+        op: "aliasCandidates",
+        scope: request.displayScope ?? request.scope,
+        errorKind,
+        error
+    };
+}
+function isAliasCandidateErrorResult(value) {
+    return isObject(value) && value.ok === false && value.op === "aliasCandidates" && typeof value.errorKind === "string";
+}
+function isAliasCandidatesOp(value) {
+    return value === "aliasCandidates" || value === "alias-candidates";
+}
+function expandAliasPayloadRequests(payload) {
+    if (Array.isArray(payload.requests)) {
+        return payload.requests.filter(isObject);
+    }
+    return [payload];
+}
+function aliasScopeRequiredError() {
+    return new errors_1.CliError("INSPECT_ALIAS_CANDIDATES_SCOPE_REQUIRED", "inspect aliasCandidates expects a directory scope.");
+}
+function safeStat(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveCliPath(cwd, filePath) {
+    return path.normalize(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
+}
+function readFlagValue(args, flag) {
+    const inlinePrefix = `${flag}=`;
+    const inline = args.find((arg) => arg.startsWith(inlinePrefix));
+    if (inline) {
+        return inline.slice(inlinePrefix.length) || null;
+    }
+    const index = args.indexOf(flag);
+    if (index < 0) {
+        return null;
+    }
+    const value = args[index + 1];
+    return value && !value.startsWith("--") ? value : null;
+}
+function readFlagValues(args, flag) {
+    const values = [];
+    const inlinePrefix = `${flag}=`;
+    for (let index = 0; index < args.length; index += 1) {
+        const inline = args[index];
+        if (inline?.startsWith(inlinePrefix)) {
+            values.push(...inline.slice(inlinePrefix.length).split(",").map((item) => item.trim()).filter(Boolean));
+            continue;
+        }
+        if (args[index] !== flag) {
+            continue;
+        }
+        const value = args[index + 1];
+        if (value && !value.startsWith("--")) {
+            values.push(...value.split(",").map((item) => item.trim()).filter(Boolean));
+            index += 1;
+        }
+    }
+    return values;
+}
+function isFlagValue(args, value) {
+    const index = args.indexOf(value);
+    return index > 0 && args[index - 1]?.startsWith("--") === true && !args[index - 1]?.includes("=");
+}
+function readPositiveIntegerFlag(args, flag) {
+    return readPositiveInteger(readFlagValue(args, flag));
+}
+function readPositiveInteger(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readStringArray(value) {
+    if (typeof value === "string" && value.length > 0) {
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function readObjectArray(value) {
+    return Array.isArray(value) ? value.filter(isObject) : [];
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}