@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/inspect-direct-usages.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDirectUsagesKeyValueArgs = parseDirectUsagesKeyValueArgs;
+const errors_1 = require("../shared/errors");
+const DIRECT_USAGE_KEYS = new Set(["target", "entity", "entities", "scope", "detail"]);
+const DIRECT_USAGE_MODIFIERS = new Set(["+all", "+includeTarget", "+excludeTarget"]);
+function parseDirectUsagesKeyValueArgs(args) {
+    if (args[0] !== "usages")
+        return null;
+    const tokens = args.slice(1);
+    if (!tokens.some((token) => token.includes("=") || token.startsWith("+")))
+        return null;
+    const request = { op: "usages" };
+    const seen = new Set();
+    for (const token of tokens) {
+        if (token.startsWith("+")) {
+            if (!DIRECT_USAGE_MODIFIERS.has(token)) {
+                throw new errors_1.CliError("UNKNOWN_INSPECT_USAGES_DIRECT_TOKEN", `Unknown inspect usages modifier: ${token}.`);
+            }
+            if (seen.has(token)) {
+                throw new errors_1.CliError("DUPLICATE_INSPECT_USAGES_DIRECT_TOKEN", `Duplicate inspect usages modifier: ${token}.`);
+            }
+            seen.add(token);
+            if (token === "+all")
+                request.all = true;
+            if (token === "+includeTarget")
+                request.includeTarget = true;
+            if (token === "+excludeTarget")
+                request.excludeTarget = true;
+            continue;
+        }
+        const separator = token.indexOf("=");
+        if (separator <= 0 || separator === token.length - 1) {
+            throw new errors_1.CliError("INVALID_INSPECT_USAGES_DIRECT_TOKEN", `Malformed inspect usages token: ${token}. Expected key=value or a supported +modifier.`);
+        }
+        const key = token.slice(0, separator);
+        const value = token.slice(separator + 1);
+        if (!DIRECT_USAGE_KEYS.has(key)) {
+            throw new errors_1.CliError("UNKNOWN_INSPECT_USAGES_DIRECT_OPTION", `Unknown inspect usages option: ${key}.`);
+        }
+        if (seen.has(key)) {
+            throw new errors_1.CliError("DUPLICATE_INSPECT_USAGES_DIRECT_OPTION", `Duplicate inspect usages option: ${key}.`);
+        }
+        seen.add(key);
+        if (key === "target") {
+            request.target = readScalar(value, key);
+        }
+        else if (key === "entity") {
+            request.entities = [readScalar(value, key)];
+        }
+        else if (key === "entities") {
+            request.entities = readList(value, key);
+        }
+        else if (key === "scope") {
+            request.scope = value.startsWith("[") ? readList(value, key) : [readScalar(value, key)];
+        }
+        else if (key === "detail") {
+            request.detail = normalizeDetail(readScalar(value, key));
+        }
+    }
+    if (typeof request.target !== "string") {
+        throw new errors_1.CliError("INSPECT_USAGES_TARGET_REQUIRED", "Direct inspect usages key-value form requires target=<file-or-dir>.");
+    }
+    if (seen.has("entity") && seen.has("entities")) {
+        throw new errors_1.CliError("INSPECT_USAGES_ENTITY_CONFLICT", "Use either entity=<selector> or entities=[...], not both.");
+    }
+    if (request.includeTarget === true && request.excludeTarget === true) {
+        throw new errors_1.CliError("INSPECT_USAGES_TARGET_MODE_CONFLICT", "Use either +includeTarget or +excludeTarget, not both.");
+    }
+    return request;
+}
+function readScalar(value, key) {
+    const normalized = value.trim();
+    if (!normalized || normalized.startsWith("[") || normalized.endsWith("]")) {
+        throw invalidValue(key, value);
+    }
+    return normalized;
+}
+function readList(value, key) {
+    if (!value.startsWith("[") || !value.endsWith("]")) {
+        throw invalidValue(key, value);
+    }
+    const items = value.slice(1, -1).split(",").map((item) => item.trim());
+    if (items.length === 0 || items.some((item) => item === "")) {
+        throw invalidValue(key, value);
+    }
+    return items;
+}
+function normalizeDetail(value) {
+    if (value === "loc" || value === "location")
+        return "locations";
+    if (value === "locations" || value === "summary" || value === "code")
+        return value;
+    throw new errors_1.CliError("INVALID_USAGES_DETAIL", "usages detail expects summary, loc, locations, or code.");
+}
+function invalidValue(key, value) {
+    return new errors_1.CliError("INVALID_INSPECT_USAGES_DIRECT_VALUE", `Invalid inspect usages value for ${key}: ${value}.`);
+}

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDuplicatesResult = formatDuplicatesResult;
+exports.formatDuplicateItem = formatDuplicateItem;
+exports.formatDuplicatesAgentText = formatDuplicatesAgentText;
+exports.formatDuplicateItemTextBlock = formatDuplicateItemTextBlock;
+const session_workspace_1 = require("./session-workspace");
+const inspect_format_primitives_1 = require("./inspect-format-primitives");
+const inspect_reference_path_format_1 = require("./inspect-reference-path-format");
+const inspect_symbol_format_1 = require("./inspect-symbol-format");
+function formatDuplicatesResult(rawResult, config, options, commonFile) {
+    const targetPaths = Array.isArray(rawResult.targetPaths)
+        ? rawResult.targetPaths.filter((item) => typeof item === "string").map((item) => (0, inspect_format_primitives_1.formatFilePath)(item, options))
+        : [];
+    const rawItems = Array.isArray(rawResult.items) ? rawResult.items.filter(inspect_format_primitives_1.isObject) : [];
+    const formatter = (0, inspect_reference_path_format_1.createDuplicatePathFormatter)();
+    const response = {
+        ...(0, inspect_format_primitives_1.baseResult)(rawResult, options, commonFile),
+        target: targetPaths.length === 1 ? formatter.compactPath(targetPaths[0]) : targetPaths.map((target) => formatter.compactPath(target)),
+        summary: typeof rawResult.summary === "string" ? rawResult.summary : `${rawItems.length} names`,
+        itemCount: (0, inspect_format_primitives_1.numberOrZero)(rawResult.itemCount),
+        returnedItemCount: (0, inspect_format_primitives_1.numberOrZero)(rawResult.returnedItemCount),
+        declarationCount: (0, inspect_format_primitives_1.numberOrZero)(rawResult.declarationCount),
+        exactCopyCount: (0, inspect_format_primitives_1.numberOrZero)(rawResult.exactCopyCount),
+        offset: (0, inspect_format_primitives_1.numberOrZero)(rawResult.offset),
+        limit: (0, inspect_format_primitives_1.numberOrZero)(rawResult.limit),
+        detail: typeof rawResult.detail === "string" ? rawResult.detail : "locations",
+        mode: typeof rawResult.mode === "string" ? rawResult.mode : "both",
+        items: rawItems.map((item) => formatDuplicateItem(item, config, options, formatter))
+    };
+    const hiddenItemCount = (0, inspect_format_primitives_1.numberOrZero)(rawResult.hiddenItemCount);
+    if (hiddenItemCount > 0) {
+        response.hidden = `+ ${hiddenItemCount} names`;
+    }
+    if (options.save) {
+        const saved = (0, session_workspace_1.saveSessionOutputJson)(options.cwd, "duplicates", options.save, rawResult);
+        response.saved = saved.saved;
+        const next = (0, session_workspace_1.useSessionGuidance)(options.cwd, "inspect.duplicates.read", `Read saved duplicates with: aib session read ${saved.saved}`);
+        if (next) {
+            response.next = next;
+        }
+    }
+    return response;
+}
+function formatDuplicateItem(item, config, options, formatter) {
+    const variants = Array.isArray(item.variants) ? item.variants.filter(inspect_format_primitives_1.isObject) : [];
+    return {
+        name: typeof item.name === "string" ? item.name : "",
+        count: (0, inspect_format_primitives_1.numberOrZero)(item.declarationCount),
+        variants: (0, inspect_format_primitives_1.numberOrZero)(item.variantCount),
+        exactCopies: (0, inspect_format_primitives_1.numberOrZero)(item.exactCopyCount),
+        groups: variants.map((variant) => formatDuplicateVariant(variant, config, options, formatter))
+    };
+}
+function formatDuplicateVariant(variant, config, options, formatter) {
+    const declarations = Array.isArray(variant.declarations) ? variant.declarations.filter(inspect_format_primitives_1.isObject) : [];
+    const result = {
+        count: (0, inspect_format_primitives_1.numberOrZero)(variant.count),
+        declarations: declarations.map((declaration) => formatDuplicateDeclaration(declaration, config, options, formatter))
+    };
+    if (typeof variant.code === "string") {
+        result.code = variant.code;
+    }
+    return result;
+}
+function formatDuplicateDeclaration(declaration, config, options, formatter) {
+    const symbol = (0, inspect_format_primitives_1.isObject)(declaration.symbol) ? declaration.symbol : {};
+    const sameAs = (0, inspect_format_primitives_1.isObject)(declaration.sameAs) ? declaration.sameAs : null;
+    const result = {
+        file: typeof declaration.file === "string" ? formatter.compactPath((0, inspect_format_primitives_1.formatFilePath)(declaration.file, options)) : "",
+        selector: (0, inspect_symbol_format_1.formatSymbolReference)(symbol, config)
+    };
+    const meta = options.includeRanges ? (0, inspect_symbol_format_1.formatMeta)(symbol) : "";
+    if (meta) {
+        result.meta = meta;
+    }
+    if (sameAs) {
+        const sameAsSymbol = (0, inspect_format_primitives_1.isObject)(sameAs.symbol) ? sameAs.symbol : {};
+        const sameAsFile = typeof sameAs.file === "string" ? formatter.compactPath((0, inspect_format_primitives_1.formatFilePath)(sameAs.file, options)) : "";
+        const sameAsMeta = options.includeRanges ? (0, inspect_symbol_format_1.formatMeta)(sameAsSymbol) : "";
+        result.sameAs = [sameAsFile, sameAsMeta].filter((part) => part !== "").join(" ");
+    }
+    return result;
+}
+function formatDuplicatesAgentText(response) {
+    const rows = Array.isArray(response.results) ? response.results.filter(inspect_format_primitives_1.isObject) : [response];
+    if (rows.length === 0) {
+        return null;
+    }
+    const lines = [];
+    for (const row of rows) {
+        const detail = typeof row.detail === "string" ? row.detail : "locations";
+        const target = Array.isArray(row.target)
+            ? row.target.filter((item) => typeof item === "string").join(", ")
+            : typeof row.target === "string" ? row.target : "";
+        const pathEntries = duplicatePathEntriesForText(row.paths, detail, target);
+        if (pathEntries.length > 0) {
+            lines.push("paths:");
+            for (const [token, prefix] of pathEntries) {
+                lines.push(`${token} = ${prefix}`);
+            }
+        }
+        lines.push(target ? `duplicates ${target}` : "duplicates");
+        if (typeof row.summary === "string") {
+            lines.push(row.summary);
+        }
+        const items = Array.isArray(row.items) ? row.items.filter(inspect_format_primitives_1.isObject) : [];
+        if (items.length === 0) {
+            lines.push("no duplicates");
+            continue;
+        }
+        for (const item of items) {
+            appendDuplicateItemText(lines, item, detail);
+        }
+        if (typeof row.hidden === "string") {
+            lines.push(row.hidden);
+        }
+        if (typeof row.view === "string") {
+            lines.push(`view: ${row.view}`);
+        }
+        if (typeof row.saved === "string") {
+            lines.push(`saved: ${row.saved}`);
+        }
+        if (typeof row.next === "string") {
+            lines.push(`next: ${row.next}`);
+        }
+    }
+    return lines.join("\n");
+}
+function duplicatePathEntriesForText(paths, detail, target) {
+    if (!(0, inspect_format_primitives_1.isObject)(paths)) {
+        return [];
+    }
+    const entries = Object.entries(paths)
+        .filter((entry) => typeof entry[1] === "string");
+    if (detail !== "summary") {
+        return entries;
+    }
+    return entries.filter(([token]) => target.includes(token));
+}
+function appendDuplicateItemText(lines, item, detail) {
+    lines.push(...formatDuplicateItemTextBlock(item, detail));
+}
+function formatDuplicateItemTextBlock(item, detail) {
+    const lines = [];
+    const name = typeof item.name === "string" ? item.name : "";
+    const count = (0, inspect_format_primitives_1.numberOrZero)(item.count);
+    const variants = (0, inspect_format_primitives_1.numberOrZero)(item.variants);
+    const exactCopies = (0, inspect_format_primitives_1.numberOrZero)(item.exactCopies);
+    if (detail !== "summary") {
+        lines.push("");
+    }
+    lines.push(`${name} x${count}, ${variants} ${plural(variants, "variant")}${exactCopies > 0 ? `, exact x${exactCopies}` : ""}`);
+    if (detail === "summary") {
+        return lines;
+    }
+    const groups = Array.isArray(item.groups) ? item.groups.filter(inspect_format_primitives_1.isObject) : [];
+    if (detail === "code") {
+        let variantIndex = 1;
+        const singleGroups = [];
+        for (const group of groups) {
+            if ((0, inspect_format_primitives_1.numberOrZero)(group.count) === 1) {
+                singleGroups.push(group);
+                continue;
+            }
+            appendDuplicateCodeGroupText(lines, group, `variant#${variantIndex}`);
+            variantIndex += 1;
+        }
+        if (singleGroups.length > 0) {
+            lines.push("// single variants");
+            for (const group of singleGroups) {
+                appendDuplicateCodeGroupText(lines, group, null);
+            }
+        }
+        return lines;
+    }
+    for (const group of groups) {
+        const declarations = Array.isArray(group.declarations) ? group.declarations.filter(inspect_format_primitives_1.isObject) : [];
+        lines.push(...formatDuplicateLocationRows(declarations, false));
+    }
+    return lines;
+}
+function appendDuplicateCodeGroupText(lines, group, label) {
+    const declarations = Array.isArray(group.declarations) ? group.declarations.filter(inspect_format_primitives_1.isObject) : [];
+    const count = (0, inspect_format_primitives_1.numberOrZero)(group.count);
+    if (label) {
+        lines.push(`// ${label} x${count}`);
+    }
+    const locationRows = formatDuplicateLocationRows(declarations, false);
+    for (const locationRow of locationRows) {
+        lines.push(`// ${locationRow}`);
+    }
+    if (typeof group.code === "string") {
+        lines.push(group.code.trimEnd());
+    }
+}
+function formatDuplicateLocationLine(declaration, includeSameAs) {
+    const file = typeof declaration.file === "string" ? declaration.file : "";
+    const meta = typeof declaration.meta === "string" ? declaration.meta : "";
+    const sameAs = includeSameAs && typeof declaration.sameAs === "string" && declaration.sameAs !== "" ? ` same as ${declaration.sameAs}` : "";
+    return [file, meta].filter((part) => part !== "").join(" ") + sameAs;
+}
+function formatDuplicateLocationRows(declarations, includeSameAs) {
+    const groups = new Map();
+    const singles = [];
+    for (const declaration of declarations) {
+        const file = typeof declaration.file === "string" ? (0, inspect_reference_path_format_1.formatUsagePath)(declaration.file) : "";
+        if (!file) {
+            continue;
+        }
+        const slashIndex = file.lastIndexOf("/");
+        if (slashIndex <= 0) {
+            singles.push(formatDuplicateLocationLine(declaration, includeSameAs));
+            continue;
+        }
+        const prefix = file.slice(0, slashIndex);
+        const basename = file.slice(slashIndex + 1);
+        const meta = typeof declaration.meta === "string" && declaration.meta !== "" ? ` ${declaration.meta}` : "";
+        const sameAs = includeSameAs && typeof declaration.sameAs === "string" && declaration.sameAs !== "" ? ` same as ${declaration.sameAs}` : "";
+        const current = groups.get(prefix) ?? [];
+        current.push(`${basename}${meta}${sameAs}`);
+        groups.set(prefix, current);
+    }
+    const grouped = Array.from(groups.entries()).flatMap(([prefix, items]) => items.length > 1 ? [`${prefix}/: ${items.join(", ")}`] : [`${prefix}/${items[0]}`]);
+    return [...grouped, ...singles].sort();
+}
+function plural(count, singular) {
+    return count === 1 ? singular : `${singular}s`;
+}

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

@@ -0,0 +1,127 @@
+"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.baseResult = baseResult;
+exports.formatFilePath = formatFilePath;
+exports.formatTextPathReferences = formatTextPathReferences;
+exports.numberOrZero = numberOrZero;
+exports.summarizeList = summarizeList;
+exports.normalizeDuplicateSourceModuleSuffix = normalizeDuplicateSourceModuleSuffix;
+exports.isInspectSymbolNotFoundResult = isInspectSymbolNotFoundResult;
+exports.readNotFoundSymbols = readNotFoundSymbols;
+exports.isObject = isObject;
+const path = __importStar(require("node:path"));
+const path_display_1 = require("../config/path-display");
+function baseResult(rawResult, options, commonFile) {
+    const result = {
+        op: typeof rawResult.op === "string" ? rawResult.op : "unknown"
+    };
+    if (typeof rawResult.id === "string") {
+        result.id = rawResult.id;
+    }
+    if (typeof rawResult.sourceFile === "string") {
+        const file = formatFilePath(rawResult.sourceFile, options);
+        if (file !== commonFile) {
+            result.file = file;
+        }
+    }
+    return result;
+}
+function formatFilePath(filePath, options) {
+    const absoluteFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(options.cwd, filePath);
+    const relativePath = path.relative(options.cwd, absoluteFilePath);
+    const normalized = (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath))
+        ? relativePath
+        : filePath;
+    const displayPath = normalized.replace(/\\/g, "/");
+    const compacted = (0, path_display_1.compactDisplayPathWithMatch)(options.cwd, absoluteFilePath, options.displayPathAliases ?? []);
+    if (compacted.alias && options.pathAliasHints) {
+        const exists = options.pathAliasHints.some((hint) => hint.alias === compacted.alias.token &&
+            hint.original === displayPath &&
+            hint.display === compacted.displayPath);
+        if (!exists) {
+            options.pathAliasHints.push({
+                alias: compacted.alias.token,
+                original: displayPath,
+                display: compacted.displayPath
+            });
+        }
+    }
+    return compacted.displayPath;
+}
+function formatTextPathReferences(text, options) {
+    const absoluteCwd = path.resolve(options.cwd);
+    const slashCwd = absoluteCwd.replace(/\\/g, "/");
+    return text
+        .replaceAll(`${absoluteCwd}\\`, "")
+        .replaceAll(`${slashCwd}/`, "")
+        .replace(/\\/g, "/");
+}
+function numberOrZero(value) {
+    return typeof value === "number" ? value : 0;
+}
+function summarizeList(items, limit, suffix = "more") {
+    if (items.length === 0) {
+        return "";
+    }
+    const visible = items.slice(0, limit);
+    const hidden = items.length - visible.length;
+    return hidden > 0 ? `${visible.join(", ")}, +${hidden} ${suffix}` : visible.join(", ");
+}
+function normalizeDuplicateSourceModuleSuffix(line) {
+    const match = line.match(/^(.*\bfrom\s+["']([^"']+)["'][^\r\n]*?)\s+from\s+([^\s]+)$/);
+    if (!match) {
+        return line;
+    }
+    const quotedModule = match[2] ?? "";
+    const trailingModule = match[3] ?? "";
+    return normalizeSourceModuleForCompare(quotedModule) === normalizeSourceModuleForCompare(trailingModule)
+        ? match[1] ?? line
+        : line;
+}
+function normalizeSourceModuleForCompare(value) {
+    return value.replace(/^["']|["']$/g, "");
+}
+function isInspectSymbolNotFoundResult(item) {
+    return item.code === "INSPECT_SYMBOL_NOT_FOUND" && readNotFoundSymbols(item).length > 0;
+}
+function readNotFoundSymbols(item) {
+    return Array.isArray(item.missingSymbols)
+        ? item.missingSymbols.filter((symbol) => typeof symbol === "string" && symbol.length > 0)
+        : [];
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}