kibi-cli 2.1.0 → 2.3.0

package/dist/commands/check.js

@@ -15,20 +15,25 @@
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
-import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { EngineClient } from "../engine.js";
-import { isCliTraceOrDebugEnabled } from "../env.js";
-import { extractFromManifest, extractFromManifestString, } from "../extractors/manifest.js";
+import { extractFromManifestString } from "../extractors/manifest.js";
 import { extractFromMarkdownString, } from "../extractors/markdown.js";
+import { createMaintenanceSourceAnalysisService, fingerprintMaintenanceSourceSet, readSnapshotSourceConfig, } from "../plugins/maintenance-source-analysis.js";
+import { analyzeSourceChanges, assertSourceAnalysisGate, } from "../plugins/source-change-analysis.js";
 import { PrologProcess } from "../prolog.js";
 import { escapeAtom, normalizeEntityId, parseTriples, parseViolationRows, } from "../prolog/codec.js";
 import { createSemanticReviewDiagnostics, createSymbolGranularityDiagnostics, createSymbolQualityDiagnostics, hasBlockingImpactDiagnostics, } from "../public/impact-diagnostics.js";
 import { executeCheck } from "../public/operations/check-executor.js";
 import { KIBI_NO_IMPACT_DECLARATION, KIBI_SYMBOLS_MANIFEST_PATH, KIBI_SYMBOL_COORDINATES_PATH, } from "../traceability/evidence-model.js";
-import { getStagedInventory, supportedStagedFiles, } from "../traceability/git-staged.js";
+import { captureStagedSnapshot } from "../traceability/git-change-snapshot.js";
+import { supportedStagedFiles, } from "../traceability/git-staged.js";
+import { evaluateImpactReview, fingerprintImpactEvaluator, hasValidBaseImpactPolicy, } from "../traceability/impact-evaluator.js";
+import { IMPACT_REVIEW_PATH } from "../traceability/impact-review.js";
 import { validateStagedMarkdown } from "../traceability/markdown-validate.js";
+import { readSnapshotKnowledge } from "../traceability/snapshot-knowledge.js";
 import { collectStagedKibiDiagnostics, } from "../traceability/staged-diagnostics.js";
+import { createStagedEntityIdStyleDiagnostics } from "../traceability/staged-entity-id-style.js";
 import { analyzeStagedFileCoverage, } from "../traceability/staged-file-coverage.js";
 import { classifyKibiImpactEvidence, isBehaviorSourceEdit, parseKibiImpactOverride, } from "../traceability/staged-impact-contract.js";
 import { assessStagedSymbolsManifest, collectStagedAuthoredSymbolsManifestEvidence, } from "../traceability/staged-symbols-manifest.js";
@@ -42,7 +47,7 @@ function getMatchGroup(match, index = 1) {
     const value = match?.[index];
     return typeof value === "string" ? value : null;
 }
-function buildManifestLookup(stagedFiles) {
+function buildManifestLookup(stagedFiles, snapshotEntities) {
     const manifestLookup = new Map();
     const manifestResults = [];
     const authoredSymbolResults = [];
@@ -68,40 +73,29 @@ function buildManifestLookup(stagedFiles) {
             results[existingIndex] = result;
         }
     };
-    // Pre-populate lookup from working-tree manifests so that code-only changes
-    // (where symbols.yaml is not staged) still resolve to the correct symbol IDs
-    // and relationships already defined on disk.
-    const symbolsRelPath = CANONICAL_ENTITY_PATHS.symbols;
-    {
-        const absSymbolsPath = path.resolve(process.cwd(), symbolsRelPath);
-        if (existsSync(absSymbolsPath)) {
-            try {
-                const entries = extractFromManifest(absSymbolsPath);
-                for (const entry of entries) {
-                    upsertResult(authoredSymbolResults, authoredSymbolIndexByKey, entry);
-                    const sourceFile = entry.sourceFile || entry.entity.source || absSymbolsPath;
-                    const key = `${sourceFile}:${entry.entity.title}`;
-                    manifestLookup.set(key, {
-                        id: entry.entity.id,
-                        relationships: entry.relationships
-                            .filter((relationship) => relationship.type === "implements" ||
-                            relationship.type === "covered_by" ||
-                            relationship.type === "executable_for")
-                            .map((relationship) => ({
-                            type: relationship.type,
-                            to: relationship.to,
-                        })),
-                    });
-                }
-            }
-            catch (e) {
-                // Ignore working-tree manifest parsing errors; staged-only fallback still applies
-                if (isCliTraceOrDebugEnabled()) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    console.debug(`[kibi] skipping working-tree manifest ${absSymbolsPath}: ${msg}`);
-                }
-            }
+    // Authored ownership comes exclusively from the captured index tree.
+    // A sentinel prevents symbol extraction from consulting working-tree manifests.
+    manifestLookup.set(createManifestLookupSentinelKey(CANONICAL_ENTITY_PATHS.symbols), { id: CANONICAL_ENTITY_PATHS.symbols });
+    const ambiguousLocators = new Set();
+    for (const entry of snapshotEntities.filter((entry) => entry.entity.type === "symbol")) {
+        upsertResult(authoredSymbolResults, authoredSymbolIndexByKey, entry);
+        const sourceFile = entry.sourceFile || entry.entity.source;
+        if (!sourceFile)
+            continue;
+        const key = `${sourceFile}:${entry.entity.title}`;
+        if (ambiguousLocators.has(key))
+            continue;
+        if (manifestLookup.has(key)) {
+            manifestLookup.delete(key);
+            ambiguousLocators.add(key);
+            continue;
         }
+        manifestLookup.set(key, {
+            id: entry.entity.id,
+            relationships: entry.relationships
+                .filter((r) => ["implements", "covered_by", "executable_for"].includes(r.type))
+                .map((r) => ({ type: r.type, to: r.to })),
+        });
     }
     const stagedManifestFiles = stagedFiles.filter((file) => file.content !== undefined &&
         (file.path === CANONICAL_ENTITY_PATHS.symbols ||
@@ -131,19 +125,6 @@ function buildManifestLookup(stagedFiles) {
                 upsertResult(manifestResults, manifestResultIndexByKey, manifestResult, true);
                 upsertResult(authoredSymbolResults, authoredSymbolIndexByKey, authoredSymbolResult, true);
                 upsertResult(stagedAuthoredSymbolResults, stagedAuthoredSymbolIndexByKey, authoredSymbolResult);
-                const sourceFile = entry.sourceFile || entry.entity.source || manifestFile.path;
-                const key = `${sourceFile}:${entry.entity.title}`;
-                manifestLookup.set(key, {
-                    id: entry.entity.id,
-                    relationships: entry.relationships
-                        .filter((relationship) => relationship.type === "implements" ||
-                        relationship.type === "covered_by" ||
-                        relationship.type === "executable_for")
-                        .map((relationship) => ({
-                        type: relationship.type,
-                        to: relationship.to,
-                    })),
-                });
             }
         }
         catch {
@@ -303,6 +284,39 @@ function printStagedResult(input) {
     if (input.operationalError)
         console.error(input.operationalError);
 }
+function clearResolvedImpactReviewAdvisories(coverage) {
+    const transport = coverage.files.find((file) => file.path === IMPACT_REVIEW_PATH);
+    const plainTransportChange = transport !== undefined &&
+        (transport.status === "A" || transport.status === "M") &&
+        transport.oldPath === undefined;
+    const reviewedPaths = new Set(coverage.files
+        .filter((file) => file.path !== IMPACT_REVIEW_PATH)
+        .map((file) => file.path));
+    coverage.diagnostics = coverage.diagnostics.filter((diagnostic) => {
+        if (diagnostic.id === "staged_file_impact_review_needed" &&
+            reviewedPaths.has(diagnostic.path)) {
+            return false;
+        }
+        return !(diagnostic.id === "staged_file_ownership_missing" &&
+            diagnostic.path === IMPACT_REVIEW_PATH &&
+            plainTransportChange);
+    });
+}
+function noValidatedSymbolsMessage(sourceAnalysis) {
+    const partialFiles = [...sourceAnalysis.values()].flatMap((analysis) => {
+        const partialSide = [analysis.before, analysis.after].find((side) => side?.status === "partial");
+        if (!partialSide)
+            return [];
+        const provider = partialSide.providerId
+            ? ` via ${partialSide.providerId}`
+            : "";
+        return [`${analysis.path}${provider}`];
+    });
+    if (partialFiles.length > 0) {
+        return `Partial source analysis was reviewed for ${partialFiles.join(", ")}; no fully analyzed exported symbols or staged entities were available for symbol validation.`;
+    }
+    return "No exported symbols or staged entities found in staged files.";
+}
 function uniqueSorted(values) {
     return Array.from(new Set(values)).sort();
 }
@@ -334,11 +348,14 @@ function buildStagedKibiImpactEvidence(options) {
     const allSourcePaths = sourceChanges.map((change) => change.path);
     const behaviorSourceFiles = sourceFiles.filter((file) => behaviorSourcePaths.includes(file.path));
     const stagedSymbolsManifest = assessStagedSymbolsManifest({
+        ...(options.analyzeSource ? { analyzeSource: options.analyzeSource } : {}),
+        ...(options.readBaseFile ? { readBaseFile: options.readBaseFile } : {}),
         symbolsManifestPath,
         stagedFiles,
         sourceFiles: behaviorSourceFiles,
     });
     const stagedAuthoredSymbolsEvidence = collectStagedAuthoredSymbolsManifestEvidence({
+        ...(options.readBaseFile ? { readBaseFile: options.readBaseFile } : {}),
         stagedFiles,
         sourceFiles: behaviorSourceFiles,
     });
@@ -435,19 +452,77 @@ export async function checkCommand(options) {
             let stagedCoverage = null;
             let tempCtx = null;
             try {
-                const stagedInventory = getStagedInventory();
-                stagedCoverage = analyzeStagedFileCoverage(stagedInventory);
+                const snapshot = captureStagedSnapshot(process.cwd());
+                const stagedInventory = snapshot.inventory;
+                const trustedSourceConfig = readSnapshotSourceConfig(snapshot, snapshot.baseTree);
+                const sourceService = createMaintenanceSourceAnalysisService(process.cwd(), trustedSourceConfig);
+                const sourceAnalysis = await analyzeSourceChanges(stagedInventory, sourceService);
+                for (const file of stagedInventory) {
+                    const analysis = sourceAnalysis.get(file.path);
+                    if (analysis?.after?.status === "ok") {
+                        file.analysisDepth = "symbol";
+                        file.disposition = "checked";
+                    }
+                }
+                const printSnapshotResult = (input) => {
+                    snapshot.assertUnchanged();
+                    printStagedResult(input);
+                };
+                stagedCoverage = analyzeStagedFileCoverage(stagedInventory, snapshot.readGit);
+                stagedCoverage.snapshot = {
+                    baseTree: snapshot.baseTree,
+                    headTree: snapshot.headTree,
+                    headCommit: snapshot.headCommit,
+                };
+                for (const record of stagedCoverage.files) {
+                    const analysis = sourceAnalysis.get(record.path);
+                    if (!analysis)
+                        continue;
+                    const describe = (side) => side
+                        ? {
+                            status: side.status,
+                            language: side.language,
+                            symbolCount: side.symbols.length,
+                            providerId: side.providerId,
+                            inputFingerprint: side.inputFingerprint,
+                            providerFingerprint: side.providerFingerprint,
+                        }
+                        : null;
+                    record.sourceAnalysis = {
+                        before: describe(analysis.before),
+                        after: describe(analysis.after),
+                    };
+                    record.providerId =
+                        analysis.after?.providerId ?? analysis.before?.providerId ?? null;
+                }
+                const impactPolicyEnabled = stagedInventory.length > 0 && hasValidBaseImpactPolicy(snapshot);
+                // One rule decides which analysis gaps block (see analysis-gate): the
+                // committed side never blocks, and an after-side local gap blocks only
+                // where it overlaps the staged lines. With a policy, the impact review
+                // evaluates the same obligations and accepts reviewed partial gaps.
+                if (!impactPolicyEnabled)
+                    assertSourceAnalysisGate(stagedInventory, sourceAnalysis);
+                if (impactPolicyEnabled) {
+                    const impactEvaluation = evaluateImpactReview(snapshot, {
+                        providerSetFingerprint: fingerprintMaintenanceSourceSet(process.cwd(), trustedSourceConfig),
+                        evaluatorFingerprint: fingerprintImpactEvaluator(),
+                        analyses: sourceAnalysis,
+                    });
+                    if (!impactEvaluation.passed)
+                        throw new Error(`Staged impact review failed:\n${impactEvaluation.diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n")}`);
+                    if (stagedCoverage) {
+                        clearResolvedImpactReviewAdvisories(stagedCoverage);
+                    }
+                }
                 const stagedFiles = supportedStagedFiles(stagedInventory);
                 if (stagedInventory.length === 0) {
-                    printStagedResult({
+                    printSnapshotResult({
                         format: options.format,
                         coverage: stagedCoverage,
                         messages: ["No staged files found."],
                     });
                     return { exitCode: 0 };
                 }
-                const { manifestLookup, manifestResults, authoredSymbolResults, stagedAuthoredSymbolResults, } = buildManifestLookup(stagedFiles);
-                const symbolsManifestPath = KIBI_SYMBOLS_MANIFEST_PATH;
                 const symbolPaths = new Set(stagedInventory
                     .filter((file) => file.analysisDepth === "symbol")
                     .map((file) => file.path));
@@ -461,7 +536,7 @@ export async function checkCommand(options) {
                     }
                 }
                 if (markdownErrors.length > 0) {
-                    printStagedResult({
+                    printSnapshotResult({
                         format: options.format,
                         coverage: stagedCoverage,
                         violations: markdownErrors.map((message) => ({
@@ -478,6 +553,12 @@ export async function checkCommand(options) {
                     }
                     return { exitCode: 1 };
                 }
+                const snapshotEntities = readSnapshotKnowledge(snapshot.readGit, snapshot.headTree, snapshot.readBlobs);
+                const snapshotRequirementIds = new Set(snapshotEntities
+                    .filter((row) => row.entity.type === "req")
+                    .map((row) => row.entity.id));
+                const { manifestLookup, manifestResults, authoredSymbolResults, stagedAuthoredSymbolResults, } = buildManifestLookup(stagedFiles, snapshotEntities);
+                const symbolsManifestPath = KIBI_SYMBOLS_MANIFEST_PATH;
                 const allSymbols = [];
                 const symbolsByFile = new Map();
                 const sourceContentByFile = new Map();
@@ -486,8 +567,16 @@ export async function checkCommand(options) {
                         if (f.content !== undefined) {
                             sourceContentByFile.set(f.path, f.content);
                         }
-                        // Maintenance path: builtin-only (no CapabilityRegistry / workspaceRoot).
-                        const symbols = await extractSymbolsFromStagedFileAsync(f, manifestLookup, {});
+                        // Maintenance uses only host-approved source analyzers over captured bytes.
+                        const symbols = await extractSymbolsFromStagedFileAsync(f, manifestLookup, {
+                            analyzeText: async () => sourceAnalysis.get(f.path)?.after ?? null,
+                        });
+                        for (const symbol of symbols) {
+                            for (const requirement of symbol.reqLinks) {
+                                if (!snapshotRequirementIds.has(requirement))
+                                    throw new Error(`Symbol ${symbol.name} references a requirement absent from the captured knowledge snapshot: ${requirement}`);
+                            }
+                        }
                         symbolsByFile.set(f.path, symbols);
                         if (symbols?.length) {
                             allSymbols.push(...symbols);
@@ -495,8 +584,7 @@ export async function checkCommand(options) {
                     }
                     catch (e) {
                         const message = `Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`;
-                        if (options.format !== "json")
-                            console.error(message);
+                        throw new Error(message);
                     }
                 }
                 const markdownResultsByPath = new Map();
@@ -514,6 +602,22 @@ export async function checkCommand(options) {
                     ...markdownResultsByPath.values(),
                 ];
                 const stagedKibiEvidence = buildStagedKibiImpactEvidence({
+                    analyzeSource: (filePath) => {
+                        const result = sourceAnalysis.get(filePath)?.after;
+                        if (!result)
+                            throw new Error(`Missing captured source analysis: ${filePath}`);
+                        return result;
+                    },
+                    readBaseFile: (filePath) => {
+                        try {
+                            return snapshot
+                                .readGit(["show", `${snapshot.baseTree}:${filePath}`])
+                                .toString("utf8");
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
                     stagedFiles,
                     sourceFiles,
                     markdownFiles,
@@ -531,7 +635,45 @@ export async function checkCommand(options) {
                 const activeGranularityResults = authoredSymbolResults.filter((result) => activeStagedSymbolEntityIds.has(result.entity.id) ||
                     (result.sourceFile !== undefined &&
                         stagedSourcePaths.has(result.sourceFile)));
+                const snapshotSymbolsByFile = new Map();
+                for (const result of activeGranularityResults) {
+                    const file = result.sourceFile;
+                    if (!file || snapshotSymbolsByFile.has(file))
+                        continue;
+                    const existing = sourceAnalysis.get(file)?.after;
+                    if (existing) {
+                        snapshotSymbolsByFile.set(file, await extractSymbolsFromStagedFileAsync({
+                            path: file,
+                            status: "M",
+                            content: "",
+                            hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
+                        }, manifestLookup, { analyzeText: async () => existing }));
+                        continue;
+                    }
+                    const entry = snapshot
+                        .readGit(["ls-tree", snapshot.headTree, "--", `:(literal)${file}`])
+                        .toString("utf8");
+                    if (!entry) {
+                        snapshotSymbolsByFile.set(file, []);
+                        continue;
+                    }
+                    if (!/^100(?:644|755) blob /.test(entry))
+                        throw new Error(`Snapshot symbol source is not a regular file: ${file}`);
+                    const content = snapshot
+                        .readGit(["show", `${snapshot.headTree}:${file}`])
+                        .toString("utf8");
+                    sourceContentByFile.set(file, content);
+                    snapshotSymbolsByFile.set(file, await extractSymbolsFromStagedFileAsync({
+                        path: file,
+                        status: "M",
+                        content,
+                        hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
+                    }, manifestLookup, {
+                        analyzeText: (name, text) => sourceService.analyzeTextV2(name, text),
+                    }));
+                }
                 stagedKibiDiagnostics.push(...createSymbolGranularityDiagnostics({
+                    sourceSymbolsByFile: snapshotSymbolsByFile,
                     manifestResults: activeGranularityResults,
                     ...(activeStagedSymbolEntityIds.size > 0
                         ? { activeEntityIds: activeStagedSymbolEntityIds }
@@ -544,51 +686,55 @@ export async function checkCommand(options) {
                         ? { activeEntityIds: activeStagedSymbolEntityIds }
                         : {}),
                     symbolsByFile,
-                }), ...createSemanticReviewDiagnostics({ symbolsByFile }));
+                }), ...createSemanticReviewDiagnostics({ symbolsByFile }), ...createStagedEntityIdStyleDiagnostics(markdownFiles));
                 if (allSymbols.length === 0 && stagedEntityResults.length === 0) {
                     if (stagedKibiDiagnostics.length > 0) {
+                        const blocking = hasBlockingImpactDiagnostics(stagedKibiDiagnostics);
                         printStagedResult({
                             format: options.format,
                             coverage: stagedCoverage,
                             qualityDiagnostics: stagedKibiDiagnostics,
-                            messages: [formatStagedKibiDiagnostics(stagedKibiDiagnostics)],
+                            messages: [
+                                formatStagedKibiDiagnostics(stagedKibiDiagnostics),
+                                // Advisory-only findings still pass; say so explicitly.
+                                ...(!blocking
+                                    ? ["✓ No violations found in staged files."]
+                                    : []),
+                            ],
                         });
                         if (options.dryRun) {
                             return { exitCode: 0 };
                         }
-                        return {
-                            exitCode: hasBlockingImpactDiagnostics(stagedKibiDiagnostics)
-                                ? 1
-                                : 0,
-                        };
+                        return { exitCode: blocking ? 1 : 0 };
                     }
-                    printStagedResult({
+                    printSnapshotResult({
                         format: options.format,
                         coverage: stagedCoverage,
-                        messages: [
-                            "No exported symbols or staged entities found in staged files.",
-                        ],
+                        messages: [noValidatedSymbolsMessage(sourceAnalysis)],
                     });
                     return { exitCode: 0 };
                 }
                 if (allSymbols.length === 0) {
                     if (stagedKibiDiagnostics.length > 0) {
+                        const blocking = hasBlockingImpactDiagnostics(stagedKibiDiagnostics);
                         printStagedResult({
                             format: options.format,
                             coverage: stagedCoverage,
                             qualityDiagnostics: stagedKibiDiagnostics,
-                            messages: [formatStagedKibiDiagnostics(stagedKibiDiagnostics)],
+                            messages: [
+                                formatStagedKibiDiagnostics(stagedKibiDiagnostics),
+                                // Advisory-only findings still pass; say so explicitly.
+                                ...(!blocking
+                                    ? ["✓ No violations found in staged files."]
+                                    : []),
+                            ],
                         });
                         if (options.dryRun) {
                             return { exitCode: 0 };
                         }
-                        return {
-                            exitCode: hasBlockingImpactDiagnostics(stagedKibiDiagnostics)
-                                ? 1
-                                : 0,
-                        };
+                        return { exitCode: blocking ? 1 : 0 };
                     }
-                    printStagedResult({
+                    printSnapshotResult({
                         format: options.format,
                         coverage: stagedCoverage,
                         messages: ["✓ No violations found in staged files."],
@@ -596,10 +742,8 @@ export async function checkCommand(options) {
                     return { exitCode: 0 };
                 }
                 // Create temp KB
-                tempCtx = await createTempKb(resolvedKbPath);
-                if (stagedEntityResults.length > 0) {
-                    await projectStagedEntities(tempCtx.prolog, stagedEntityResults);
-                }
+                tempCtx = await createTempKb();
+                await projectStagedEntities(tempCtx.prolog, snapshotEntities);
                 const overlayFacts = createOverlayFacts(allSymbols);
                 const fs = await import("node:fs/promises");
                 await fs.writeFile(tempCtx.overlayPath, overlayFacts, "utf8");
@@ -611,7 +755,7 @@ export async function checkCommand(options) {
                 });
                 const violationsFormatted = formatStagedViolations(violationsRaw);
                 if (violationsRaw && violationsRaw.length > 0) {
-                    printStagedResult({
+                    printSnapshotResult({
                         format: options.format,
                         coverage: stagedCoverage,
                         violations: violationsRaw,
@@ -632,7 +776,7 @@ export async function checkCommand(options) {
                 if (stagedKibiDiagnostics.length > 0) {
                     await cleanupTempKb(tempCtx.tempDir);
                     const blocking = hasBlockingImpactDiagnostics(stagedKibiDiagnostics);
-                    printStagedResult({
+                    printSnapshotResult({
                         format: options.format,
                         coverage: stagedCoverage,
                         qualityDiagnostics: stagedKibiDiagnostics,
@@ -653,7 +797,7 @@ export async function checkCommand(options) {
                         exitCode: 1,
                     };
                 }
-                printStagedResult({
+                printSnapshotResult({
                     format: options.format,
                     coverage: stagedCoverage,
                     messages: ["✓ No violations found in staged symbols."],
@@ -850,6 +994,7 @@ export async function checkNoDanglingRefs(prolog) {
         "constrains",
         "requires_property",
         "supersedes",
+        "restates",
         "relates_to",
     ];
     const allRels = [];

package/dist/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AA6DA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,aAAa,CACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAwF/B;AAED,wBAAsB,4BAA4B,CAChD,IAAI,GAAE,MAAM,OAAO,CAAC;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,CACT,GACxC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;MAkE3C;AAkGD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAepB"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AA+EA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,aAAa,CACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgG/B;AAED,wBAAsB,4BAA4B,CAChD,IAAI,GAAE,MAAM,OAAO,CAAC;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,CACT,GACxC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;MAkE3C;AAkGD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAepB"}