@lousy-agents/cli 5.16.0 → 5.17.0

package/dist/index.js

@@ -2990,7 +2990,7 @@ exports.basename = (path, { windows } = {}) => {
 
 
 },
-149(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+889(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -11160,7 +11160,7 @@ function handleIntersectionResults(result, left, right) {
     result.value = merged.data;
     return result;
 }
-const $ZodTuple = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("$ZodTuple", (inst, def) => {
+const $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def) => {
     $ZodType.init(inst, def);
     const items = def.items;
     inst._zod.parse = (payload, ctx) => {
@@ -11236,7 +11236,7 @@ const $ZodTuple = /*@__PURE__*/ (/* unused pure expression or super */ null && (
         }
         return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
-})));
+});
 function getTupleOptStart(items, key) {
     for (let i = items.length - 1; i >= 0; i--) {
         if (items[i]._zod[key] !== "optional")
@@ -11246,7 +11246,7 @@ function getTupleOptStart(items, key) {
 }
 function handleTupleResult(result, final, index) {
     if (result.issues.length) {
-        final.issues.push(...util.prefixIssues(index, result.issues));
+        final.issues.push(...prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
 }
@@ -11262,7 +11262,7 @@ function handleTupleResults(itemResults, final, items, input, optoutStart) {
                 final.value.length = i;
                 break;
             }
-            final.issues.push(...util.prefixIssues(i, r.issues));
+            final.issues.push(...prefixIssues(i, r.issues));
         }
         final.value[i] = r.value;
     }
@@ -14046,12 +14046,12 @@ const tupleProcessor = (schema, ctx, _json, params) => {
     json.type = "array";
     const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
     const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-    const prefixItems = def.items.map((x, i) => process(x, ctx, {
+    const prefixItems = def.items.map((x, i) => to_json_schema_process(x, ctx, {
         ...params,
         path: [...params.path, prefixPath, i],
     }));
     const rest = def.rest
-        ? process(def.rest, ctx, {
+        ? to_json_schema_process(def.rest, ctx, {
             ...params,
             path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
         })
@@ -15257,24 +15257,24 @@ function intersection(left, right) {
         right: right,
     });
 }
-const ZodTuple = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("ZodTuple", (inst, def) => {
-    core.$ZodTuple.init(inst, def);
+const ZodTuple = /*@__PURE__*/ $constructor("ZodTuple", (inst, def) => {
+    $ZodTuple.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);
+    inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
     inst.rest = (rest) => inst.clone({
         ...inst._zod.def,
         rest: rest,
     });
-})));
+});
 function tuple(items, _paramsOrRest, _params) {
-    const hasRest = _paramsOrRest instanceof core.$ZodType;
+    const hasRest = _paramsOrRest instanceof $ZodType;
     const params = hasRest ? _params : _paramsOrRest;
     const rest = hasRest ? _paramsOrRest : null;
     return new ZodTuple({
         type: "tuple",
         items: items,
         rest,
-        ...util.normalizeParams(params),
+        ...normalizeParams(params),
     });
 }
 const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
@@ -28402,22 +28402,206 @@ function hasBlockingFindings(findings) {
     return findings.some((f)=>(f.severity === "critical" || f.severity === "high") && f.classification === "defect");
 }
 
+;// CONCATENATED MODULE: ../doctor/src/lib/cross-harness-edges.ts
+function resolveEdgeTargets(edge) {
+    return Array.isArray(edge.direction.to) ? edge.direction.to : [
+        edge.direction.to
+    ];
+}
+function buildHarnessByPath(records) {
+    const harnessByPath = new Map();
+    for (const record of records){
+        harnessByPath.set(record.path, record.harness);
+    }
+    return harnessByPath;
+}
+function isCrossHarnessTarget(edge, targetPath, sourceHarness, harnessByPath) {
+    if (edge.malformed || edge.type === "glob-binding") return false;
+    const targetHarness = harnessByPath.get(targetPath);
+    return targetHarness !== undefined && targetHarness !== sourceHarness;
+}
+function countCrossHarnessEdges(records) {
+    const harnessByPath = buildHarnessByPath(records);
+    let count = 0;
+    for (const record of records){
+        for (const edge of record.edges){
+            for (const target of resolveEdgeTargets(edge)){
+                if (isCrossHarnessTarget(edge, target, record.harness, harnessByPath)) {
+                    count++;
+                }
+            }
+        }
+    }
+    return count;
+}
+
 ;// CONCATENATED MODULE: ../doctor/src/formatters/json-formatter.ts
-function toJson(summary, findings, snapshotRef) {
-    return {
+
+
+const HarnessNameSchema = schemas_enum([
+    "claude",
+    "copilot",
+    "codex",
+    "antigravity",
+    "hermes",
+    "crush",
+    "pi",
+    "shared"
+]);
+const ConstructTypeSchema = schemas_enum([
+    "instruction",
+    "skill",
+    "agent",
+    "subagent",
+    "mcp-server",
+    "plugin",
+    "hook"
+]);
+const EdgeTypeSchema = schemas_enum([
+    "hard-import",
+    "soft-reference",
+    "glob-binding"
+]);
+const ArchetypeSchema = schemas_enum([
+    "pure",
+    "intentional-hybrid",
+    "canonical-contract",
+    "accidental-sprawl",
+    "none",
+    "ambiguous"
+]);
+const CitationHandleSchema = schemas_object({
+    nodeId: schemas_string(),
+    sourceFile: schemas_string(),
+    lineRange: tuple([
+        schemas_number(),
+        schemas_number()
+    ]).optional(),
+    snapshotRef: schemas_string().optional()
+});
+const FindingSchema = schemas_object({
+    id: schemas_string(),
+    criterionId: schemas_string(),
+    targetId: schemas_string(),
+    severity: schemas_enum([
+        "critical",
+        "high",
+        "medium",
+        "low",
+        "info"
+    ]),
+    category: schemas_enum([
+        "missing-required",
+        "malformed-reference",
+        "wrong-direction",
+        "drift",
+        "governance",
+        "composition-style"
+    ]),
+    classification: schemas_enum([
+        "defect",
+        "advisory",
+        "info"
+    ]),
+    intentGated: schemas_boolean(),
+    assumedIntent: schemas_boolean(),
+    description: schemas_string(),
+    evidenceCitation: CitationHandleSchema.optional(),
+    snapshotRef: schemas_string().optional()
+});
+const ReportInventoryItemSchema = schemas_object({
+    id: schemas_string(),
+    path: schemas_string(),
+    harness: HarnessNameSchema,
+    constructType: ConstructTypeSchema,
+    loadMechanism: schemas_enum([
+        "referenced",
+        "convention-loaded"
+    ]),
+    serverName: schemas_string().optional(),
+    transport: schemas_string().optional()
+});
+const ReportEdgeSchema = schemas_object({
+    from: schemas_string(),
+    to: schemas_string(),
+    type: EdgeTypeSchema,
+    malformed: schemas_boolean(),
+    reason: schemas_enum([
+        "missing-target",
+        "path-traversal"
+    ]).optional(),
+    crossHarness: schemas_boolean()
+});
+const ReportJsonSchema = schemas_object({
+    archetype: ArchetypeSchema,
+    dominanceScore: schemas_number(),
+    totalRecords: schemas_number(),
+    harnessBreakdown: schemas_array(schemas_object({
+        harness: schemas_string(),
+        count: schemas_number()
+    })),
+    crossHarnessEdges: schemas_number(),
+    inventory: schemas_array(ReportInventoryItemSchema),
+    edges: schemas_array(ReportEdgeSchema),
+    findings: schemas_array(FindingSchema),
+    snapshotRef: schemas_string().optional()
+});
+function toInventoryItems(records) {
+    return records.map((record)=>({
+            id: record.id,
+            path: record.path,
+            harness: record.harness,
+            constructType: record.constructType,
+            loadMechanism: record.loadMechanism,
+            ...record.serverName !== undefined ? {
+                serverName: record.serverName
+            } : {},
+            ...record.transport !== undefined ? {
+                transport: record.transport
+            } : {}
+        })).sort((a, b)=>a.path.localeCompare(b.path) || a.id.localeCompare(b.id));
+}
+function toReportEdges(records) {
+    const harnessByPath = buildHarnessByPath(records);
+    const result = [];
+    for (const record of records){
+        for (const edge of record.edges){
+            for (const target of resolveEdgeTargets(edge)){
+                result.push({
+                    from: edge.direction.from,
+                    to: target,
+                    type: edge.type,
+                    malformed: edge.malformed,
+                    ...edge.reason !== undefined ? {
+                        reason: edge.reason
+                    } : {},
+                    crossHarness: isCrossHarnessTarget(edge, target, record.harness, harnessByPath)
+                });
+            }
+        }
+    }
+    return result;
+}
+function toJson(summary, findings, records, snapshotRef) {
+    const edges = toReportEdges(records);
+    const report = {
         archetype: summary.archetype,
         dominanceScore: summary.dominanceScore,
         totalRecords: summary.totalRecords,
         harnessBreakdown: summary.harnessBreakdown,
-        crossHarnessEdges: summary.crossHarnessEdges,
+        crossHarnessEdges: edges.filter((edge)=>edge.crossHarness).length,
+        inventory: toInventoryItems(records),
+        edges,
         findings,
         ...snapshotRef !== undefined ? {
             snapshotRef
         } : {}
     };
+    return ReportJsonSchema.parse(report);
 }
 
 ;// CONCATENATED MODULE: ../doctor/src/formatters/summary-formatter.ts
+
 const ARCHETYPE_DESCRIPTIONS = {
     pure: "Single-harness configuration. One AI coding assistant dominates the repository.",
     "intentional-hybrid": "Multi-harness configuration with cross-harness references. Harnesses deliberately share context.",
@@ -28435,21 +28619,7 @@ function formatSummary(records, classification) {
             harness,
             count
         })).sort((a, b)=>a.harness.localeCompare(b.harness));
-    let crossHarnessEdges = 0;
-    const harnessByPath = new Map();
-    for (const r of records){
-        harnessByPath.set(r.path, r.harness);
-    }
-    for (const r of records){
-        for (const edge of r.edges){
-            if (!edge.malformed && edge.type !== "glob-binding" && typeof edge.direction.to === "string") {
-                const targetHarness = harnessByPath.get(edge.direction.to);
-                if (targetHarness && targetHarness !== r.harness) {
-                    crossHarnessEdges++;
-                }
-            }
-        }
-    }
+    const crossHarnessEdges = countCrossHarnessEdges(records);
     return {
         archetype: classification.archetype,
         archetypeDescription: ARCHETYPE_DESCRIPTIONS[classification.archetype],
@@ -28841,11 +29011,69 @@ function parseRawEdges(content) {
     return edges;
 }
 
+;// CONCATENATED MODULE: ../doctor/src/gateways/mcp-config.ts
+
+
+const MAX_MCP_CONFIG_BYTES = 1_048_576;
+const MCP_CONFIG_SOURCES = [
+    {
+        relPath: ".mcp.json",
+        harness: "shared"
+    },
+    {
+        relPath: ".vscode/mcp.json",
+        harness: "copilot"
+    }
+];
+const McpServerEntrySchema = schemas_object({
+    type: schemas_string().optional(),
+    transport: schemas_string().optional()
+}).passthrough();
+const McpConfigSchema = schemas_object({
+    mcpServers: schemas_record(schemas_string(), McpServerEntrySchema).optional()
+}).passthrough();
+async function readMcpServersFromSource(repoRoot, source) {
+    let content;
+    try {
+        content = await file_system_utils_readTextWithinRoot(repoRoot, source.relPath, MAX_MCP_CONFIG_BYTES);
+    } catch  {
+        return [];
+    }
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    } catch  {
+        return [];
+    }
+    const result = McpConfigSchema.safeParse(raw);
+    if (!result.success || result.data.mcpServers === undefined) {
+        return [];
+    }
+    return Object.entries(result.data.mcpServers).map(([serverName, entry])=>({
+            serverName,
+            harness: source.harness,
+            path: source.relPath,
+            ...entry.transport !== undefined ? {
+                transport: entry.transport
+            } : entry.type !== undefined ? {
+                transport: entry.type
+            } : {}
+        }));
+}
+async function enumerateMcpServers(repoRoot) {
+    const records = [];
+    for (const source of MCP_CONFIG_SOURCES){
+        records.push(...await readMcpServersFromSource(repoRoot, source));
+    }
+    return records;
+}
+
 ;// CONCATENATED MODULE: ../doctor/src/gateways/scanner.ts
 
 
 
 
+
 const MAX_FILE_BYTES = 1_048_576;
 const SCANNABLE_EXTENSIONS = new Set([
     ".md",
@@ -28882,6 +29110,9 @@ function determineConstructType(relPath) {
     if (relPath.startsWith(".claude/hooks/")) {
         return "hook";
     }
+    if (relPath.startsWith(".claude/agents/")) {
+        return "subagent";
+    }
     if (relPath.startsWith(".claude/commands/")) {
         return "agent";
     }
@@ -29025,6 +29256,21 @@ async function scanRepository(repoRoot) {
             record.loadMechanism = "referenced";
         }
     }
+    const mcpServers = await enumerateMcpServers(absRoot);
+    for (const server of mcpServers){
+        records.push({
+            id: `mcp-server:${server.path}#${server.serverName}`,
+            path: server.path,
+            harness: server.harness,
+            constructType: "mcp-server",
+            loadMechanism: "convention-loaded",
+            edges: [],
+            serverName: server.serverName,
+            ...server.transport !== undefined ? {
+                transport: server.transport
+            } : {}
+        });
+    }
     return records;
 }
 
@@ -29619,7 +29865,8 @@ const doctorCommand = defineCommand({
                     dominanceScore: summary.dominanceScore,
                     totalRecords: summary.totalRecords,
                     harnessBreakdown: summary.harnessBreakdown,
-                    crossHarnessEdges: summary.crossHarnessEdges
+                    crossHarnessEdges: summary.crossHarnessEdges,
+                    inventory: toInventoryItems(records)
                 }, null, 2)}\n`);
             } else {
                 renderHuman(summary, [], logger, snapshotRef);
@@ -29628,7 +29875,7 @@ const doctorCommand = defineCommand({
         }
         if (classification.archetype === "none") {
             if (format === "json") {
-                process.stdout.write(`${JSON.stringify(toJson(summary, [], snapshotRef), null, 2)}\n`);
+                process.stdout.write(`${JSON.stringify(toJson(summary, [], records, snapshotRef), null, 2)}\n`);
             } else {
                 logger.info("No agentic constructs found in the repository.");
             }
@@ -29660,7 +29907,7 @@ const doctorCommand = defineCommand({
             intent
         });
         if (format === "json") {
-            const report = toJson(summary, findings, snapshotRef);
+            const report = toJson(summary, findings, records, snapshotRef);
             process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
         } else {
             renderHuman(summary, findings, logger, snapshotRef);
@@ -61374,4 +61621,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(149);
+var __webpack_exports__ = __webpack_require__(889);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/cli",
-    "version": "5.16.0",
+    "version": "5.17.0",
     "description": "CLI scaffolding tool that sets up projects with structure, instructions, and feedback loops for AI coding assistants",
     "type": "module",
     "repository": {