@praneeth_54/agentdoctor 0.3.0-beta → 1.1.0

package/dist/core/understanding/entrypoints/models.js

@@ -0,0 +1,216 @@
+function basename(relativePath) {
+    const parts = relativePath.split("/");
+    return parts[parts.length - 1] ?? relativePath;
+}
+function posix(relativePath) {
+    return relativePath.replace(/\\/g, "/");
+}
+/**
+ * Deterministic entrypoint models. Order matters for stable multi-match preference
+ * when the same file could qualify under multiple frameworks (NestJS before Node).
+ */
+export const ENTRYPOINT_MODELS = [
+    {
+        framework: "Flutter",
+        pathTest: (p) => {
+            const path = posix(p);
+            return (path === "lib/main.dart" ||
+                path.endsWith("/lib/main.dart") ||
+                basename(path) === "main.dart");
+        },
+        signals: [
+            { label: "runApp()", pattern: /\brunApp\s*\(/ },
+            { label: "MaterialApp", pattern: /\bMaterialApp\b/ },
+            { label: "CupertinoApp", pattern: /\bCupertinoApp\b/ },
+            { label: "GoRouter", pattern: /\bGoRouter\b/ },
+        ],
+        pathConfidence: 0.7,
+        signalBoost: 0.1,
+        requireSignal: false,
+    },
+    {
+        framework: "Laravel",
+        pathTest: (p) => {
+            const path = posix(p);
+            return (path === "routes/web.php" ||
+                path === "routes/api.php" ||
+                path.endsWith("/routes/web.php") ||
+                path.endsWith("/routes/api.php") ||
+                basename(path) === "artisan" ||
+                path === "bootstrap/app.php" ||
+                path.endsWith("/bootstrap/app.php"));
+        },
+        signals: [
+            { label: "Route::", pattern: /\bRoute\s*::/ },
+            { label: "Illuminate\\", pattern: /Illuminate\\/ },
+            { label: "Application::configure", pattern: /Application\s*::\s*configure/ },
+        ],
+        pathConfidence: 0.85,
+        signalBoost: 0.05,
+        requireSignal: false,
+    },
+    {
+        framework: "Next.js",
+        pathTest: (p) => {
+            const path = posix(p);
+            const base = basename(path);
+            const inApp = /(^|\/)app\//.test(path) &&
+                (base === "layout.tsx" ||
+                    base === "layout.jsx" ||
+                    base === "layout.js" ||
+                    base === "page.tsx" ||
+                    base === "page.jsx" ||
+                    base === "page.js");
+            const inPages = /(^|\/)pages\//.test(path) &&
+                (base === "_app.tsx" ||
+                    base === "_app.jsx" ||
+                    base === "_app.js" ||
+                    base === "index.tsx" ||
+                    base === "index.jsx" ||
+                    base === "index.js");
+            return inApp || inPages;
+        },
+        signals: [
+            { label: "next/navigation", pattern: /from\s+["']next\/navigation["']/ },
+            { label: "next/router", pattern: /from\s+["']next\/router["']/ },
+            { label: "next/head", pattern: /from\s+["']next\/head["']/ },
+            { label: "Metadata", pattern: /\bexport\s+(const|async\s+function|function)\s+metadata\b/ },
+        ],
+        pathConfidence: 0.8,
+        signalBoost: 0.06,
+        requireSignal: false,
+    },
+    {
+        framework: "NestJS",
+        pathTest: (p) => {
+            const path = posix(p);
+            const base = basename(path);
+            return base === "main.ts" || base === "main.js";
+        },
+        signals: [
+            { label: "NestFactory", pattern: /\bNestFactory\b/ },
+            {
+                label: "bootstrap()",
+                pattern: /\basync\s+function\s+bootstrap\s*\(|\bbootstrap\s*\(\s*\)/,
+            },
+            { label: "@nestjs/core", pattern: /@nestjs\/core/ },
+        ],
+        pathConfidence: 0.55,
+        signalBoost: 0.15,
+        requireSignal: true,
+    },
+    {
+        framework: "React",
+        pathTest: (p) => {
+            const path = posix(p);
+            const base = basename(path);
+            if (/(^|\/)(app|pages)\//.test(path)) {
+                return false;
+            }
+            return (base === "main.tsx" ||
+                base === "main.jsx" ||
+                base === "index.tsx" ||
+                base === "index.jsx" ||
+                base === "App.tsx" ||
+                base === "App.jsx");
+        },
+        signals: [
+            { label: "ReactDOM.createRoot()", pattern: /ReactDOM\s*\.\s*createRoot\s*\(/ },
+            { label: "createRoot()", pattern: /\bcreateRoot\s*\(/ },
+            { label: "ReactDOM.render(", pattern: /ReactDOM\s*\.\s*render\s*\(/ },
+            { label: 'from "react"', pattern: /from\s+["']react["']/ },
+        ],
+        pathConfidence: 0.6,
+        signalBoost: 0.12,
+        requireSignal: true,
+    },
+    {
+        framework: "Node",
+        pathTest: (p) => {
+            const path = posix(p);
+            const base = basename(path);
+            return (base === "server.ts" ||
+                base === "server.js" ||
+                base === "server.mjs" ||
+                base === "app.ts" ||
+                base === "app.js" ||
+                base === "app.mjs" ||
+                base === "index.ts" ||
+                base === "index.js");
+        },
+        signals: [
+            { label: "express()", pattern: /\bexpress\s*\(/ },
+            { label: "fastify()", pattern: /\bfastify\s*\(/ },
+            { label: "createServer(", pattern: /\bcreateServer\s*\(/ },
+            { label: "listen(", pattern: /\.listen\s*\(/ },
+            { label: "koa(", pattern: /\bnew\s+Koa\s*\(|\bkoa\s*\(/ },
+        ],
+        pathConfidence: 0.5,
+        signalBoost: 0.15,
+        requireSignal: true,
+    },
+    {
+        framework: "Django",
+        pathTest: (p) => basename(posix(p)) === "manage.py",
+        signals: [
+            { label: "django", pattern: /\bdjango\b/i },
+            { label: "execute_from_command_line", pattern: /\bexecute_from_command_line\b/ },
+        ],
+        pathConfidence: 0.9,
+        signalBoost: 0.04,
+        requireSignal: false,
+    },
+    {
+        framework: "Python",
+        pathTest: (p) => {
+            const base = basename(posix(p));
+            return base === "main.py" || base === "app.py" || base === "wsgi.py" || base === "asgi.py";
+        },
+        signals: [
+            { label: "FastAPI()", pattern: /\bFastAPI\s*\(/ },
+            { label: "Flask(", pattern: /\bFlask\s*\(/ },
+            { label: "uvicorn", pattern: /\buvicorn\b/ },
+            { label: "if __name__", pattern: /if\s+__name__\s*==\s*["']__main__["']/ },
+        ],
+        pathConfidence: 0.55,
+        signalBoost: 0.15,
+        requireSignal: true,
+    },
+    {
+        framework: "Java",
+        pathTest: (p) => {
+            const path = posix(p);
+            return path.endsWith(".java") && /Application\.java$|Main\.java$/i.test(basename(path));
+        },
+        signals: [
+            { label: "@SpringBootApplication", pattern: /@SpringBootApplication\b/ },
+            { label: "public static void main", pattern: /public\s+static\s+void\s+main\s*\(/ },
+            { label: "SpringApplication.run", pattern: /\bSpringApplication\s*\.\s*run\s*\(/ },
+        ],
+        pathConfidence: 0.55,
+        signalBoost: 0.15,
+        requireSignal: true,
+    },
+    {
+        framework: "Go",
+        pathTest: (p) => basename(posix(p)) === "main.go",
+        signals: [
+            { label: "package main", pattern: /^package\s+main\b/m },
+            { label: "func main()", pattern: /\bfunc\s+main\s*\(\s*\)/ },
+        ],
+        pathConfidence: 0.65,
+        signalBoost: 0.15,
+        requireSignal: true,
+    },
+    {
+        framework: "Rust",
+        pathTest: (p) => {
+            const path = posix(p);
+            return (path === "src/main.rs" || path.endsWith("/src/main.rs") || basename(path) === "main.rs");
+        },
+        signals: [{ label: "fn main()", pattern: /\bfn\s+main\s*\(\s*\)/ }],
+        pathConfidence: 0.7,
+        signalBoost: 0.2,
+        requireSignal: true,
+    },
+];

package/dist/core/understanding/entrypoints/types.d.ts

@@ -0,0 +1,20 @@
+export type EntrypointFramework = "Flutter" | "Laravel" | "React" | "Next.js" | "Node" | "NestJS" | "Python" | "Django" | "Java" | "Go" | "Rust";
+export interface EntrypointMatch {
+    framework: EntrypointFramework;
+    file: string;
+    confidence: number;
+    evidence: string[];
+}
+export interface EntrypointDiscoveryResult {
+    entrypoints: EntrypointMatch[];
+    timingMs: number;
+    filesConsidered: number;
+    filesInspected: number;
+}
+export interface EntrypointDiscoveryOptions {
+    cwd?: string;
+    /** Minimum confidence to include (0–1). Default 0.55. */
+    minConfidence?: number;
+    /** Max bytes to read from a candidate file. Default 256 KiB. */
+    maxReadBytes?: number;
+}

package/dist/core/understanding/entrypoints/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/understanding/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Internal Software Understanding Engine.
+ * Not wired into scan/CLI. Import from this module only.
+ */
+export { discoverDomains, scoreDomainConfidence } from "./domain/index.js";
+export { discoverEntrypoints, scoreEntrypointConfidence, ENTRYPOINT_MODELS, } from "./entrypoints/index.js";
+export { discoverDependencies, scoreDependencyConfidence, extractReferences, RELATION_CONFIDENCE, } from "./dependencies/index.js";
+export { discoverRelationships, scoreRelationshipConfidence, classifyComponent, classifyRoleFromPath, extractSemanticSignals, ROLE_PAIR_RULES, } from "./relationships/index.js";
+export { inferArchitectures, ARCHITECTURE_RULES, listArchitecturePatterns, scorePatternConfidence, } from "./architecture/index.js";
+export { ProjectModelBuilder, buildProjectModel, serializeProjectModel, parseProjectModel, validateProjectModel, PROJECT_MODEL_SCHEMA, PROJECT_MODEL_SCHEMA_VERSION, UNDERSTANDING_COMPILER_VERSION, } from "./model/index.js";
+export { QueryEngine, createQueryEngine, Queries, executeQuery, validateQuery, listSupportedQueryTypes, QueryError, QueryValidationError, QueryNotFoundError, QueryUnsupportedError, } from "./query/index.js";
+export { UnderstandService, createUnderstandService, understandAsText, UNDERSTAND_LIMITATIONS, } from "./understand/index.js";
+export { discoverOwnership, ownersForPath, matchCodeownersPattern, scoreOwnershipConfidence, } from "./ownership/index.js";
+export { discoverRisks } from "./risks/index.js";
+export { computeContentHash, createSnapshotIdentity, hashSerializedModel, } from "./snapshot/index.js";
+export { compareProjectModels } from "./delta/index.js";
+export { buildProjectMind, buildProjectMindSync, extractClaims, findMindClaim, findMindOwner, findMindRisks, listMindOwnership, listMindRisks, mindSummary, PROJECT_MIND_LIMITATIONS, } from "./mind/index.js";
+export type { DomainDiscoveryOptions, DomainDiscoveryResult, DomainMatch, UnderstandingConfidence, UnderstandingEvidence, } from "./types/index.js";
+export type { EntrypointDiscoveryOptions, EntrypointDiscoveryResult, EntrypointFramework, EntrypointMatch, } from "./entrypoints/types.js";
+export type { DependencyDiscoveryOptions, DependencyDiscoveryResult, DependencyMatch, DependencyRelationType, ExtractedReference, } from "./dependencies/types.js";
+export type { RelationshipDiscoveryOptions, RelationshipDiscoveryResult, RelationshipKind, RelationshipMatch, RelationshipStrength, ComponentRole, } from "./relationships/types.js";
+export type { ArchitectureInferenceInput, ArchitectureInferenceOptions, ArchitectureInferenceResult, ArchitectureMatch, ArchitecturePattern, } from "./architecture/types.js";
+export type { ProjectModel, ProjectModelBuilderInput, ProjectModelValidationResult, CompilerPassId, } from "./model/types.js";
+export type { Query, QueryType, QueryResponse, QueryMetadata, FindDomainResult, RepositorySummaryResult, } from "./query/index.js";
+export type { UnderstandResult, UnderstandSection, UnderstandSnapshot, UnderstandServiceOptions, } from "./understand/types.js";
+export type { OwnershipDiscoveryOptions, OwnershipDiscoveryResult, OwnershipMatch, OwnershipSource, } from "./ownership/index.js";
+export type { RiskDiscoveryOptions, RiskDiscoveryResult, RiskKind, RiskMatch, RiskSeverity, } from "./risks/index.js";
+export type { SnapshotIdentity } from "./snapshot/index.js";
+export type { SetDelta, UnderstandingDelta } from "./delta/index.js";
+export type { BuildProjectMindOptions, ClaimKind, ProjectClaim, ProjectMind, } from "./mind/index.js";
+export { buildProjectBrain, createBrainQueryEngine, BrainQueryEngine, explainClaim, traceBrain, buildBrainDelta, serializeBrainDelta, parseBrainDelta, LocalBrainStore, BrainStorageError, serializeBrain, CONFIDENCE_CONTRACT, PROJECT_BRAIN_SCHEMA_VERSION, BRAIN_STORAGE_FORMAT_VERSION, PROJECT_BRAIN_LIMITATIONS, PROJECT_BRAIN_CONTRACT, assertBrainContract, redactBrainForStorage, applyClaimLifecycle, detectContradictions, } from "./brain/index.js";
+export type { ProjectBrain, BrainClaim, BrainEvidence, BrainDelta, BrainQuery, BrainQueryResponse, ClaimExplanation, TraceResult, TraceMode, SnapshotMeta, BrainComponent, ClaimStatus, BuildProjectBrainOptions, } from "./brain/index.js";

package/dist/core/understanding/index.js

@@ -0,0 +1,18 @@
+/**
+ * Internal Software Understanding Engine.
+ * Not wired into scan/CLI. Import from this module only.
+ */
+export { discoverDomains, scoreDomainConfidence } from "./domain/index.js";
+export { discoverEntrypoints, scoreEntrypointConfidence, ENTRYPOINT_MODELS, } from "./entrypoints/index.js";
+export { discoverDependencies, scoreDependencyConfidence, extractReferences, RELATION_CONFIDENCE, } from "./dependencies/index.js";
+export { discoverRelationships, scoreRelationshipConfidence, classifyComponent, classifyRoleFromPath, extractSemanticSignals, ROLE_PAIR_RULES, } from "./relationships/index.js";
+export { inferArchitectures, ARCHITECTURE_RULES, listArchitecturePatterns, scorePatternConfidence, } from "./architecture/index.js";
+export { ProjectModelBuilder, buildProjectModel, serializeProjectModel, parseProjectModel, validateProjectModel, PROJECT_MODEL_SCHEMA, PROJECT_MODEL_SCHEMA_VERSION, UNDERSTANDING_COMPILER_VERSION, } from "./model/index.js";
+export { QueryEngine, createQueryEngine, Queries, executeQuery, validateQuery, listSupportedQueryTypes, QueryError, QueryValidationError, QueryNotFoundError, QueryUnsupportedError, } from "./query/index.js";
+export { UnderstandService, createUnderstandService, understandAsText, UNDERSTAND_LIMITATIONS, } from "./understand/index.js";
+export { discoverOwnership, ownersForPath, matchCodeownersPattern, scoreOwnershipConfidence, } from "./ownership/index.js";
+export { discoverRisks } from "./risks/index.js";
+export { computeContentHash, createSnapshotIdentity, hashSerializedModel, } from "./snapshot/index.js";
+export { compareProjectModels } from "./delta/index.js";
+export { buildProjectMind, buildProjectMindSync, extractClaims, findMindClaim, findMindOwner, findMindRisks, listMindOwnership, listMindRisks, mindSummary, PROJECT_MIND_LIMITATIONS, } from "./mind/index.js";
+export { buildProjectBrain, createBrainQueryEngine, BrainQueryEngine, explainClaim, traceBrain, buildBrainDelta, serializeBrainDelta, parseBrainDelta, LocalBrainStore, BrainStorageError, serializeBrain, CONFIDENCE_CONTRACT, PROJECT_BRAIN_SCHEMA_VERSION, BRAIN_STORAGE_FORMAT_VERSION, PROJECT_BRAIN_LIMITATIONS, PROJECT_BRAIN_CONTRACT, assertBrainContract, redactBrainForStorage, applyClaimLifecycle, detectContradictions, } from "./brain/index.js";

package/dist/core/understanding/mind/build.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectModel } from "../model/types.js";
+import { type OwnershipDiscoveryResult } from "../ownership/index.js";
+import { type RiskDiscoveryResult } from "../risks/index.js";
+import { type ProjectClaim, type ProjectMind } from "./types.js";
+export declare function extractClaims(model: ProjectModel, ownership: OwnershipDiscoveryResult, risks: RiskDiscoveryResult, snapshotId: string): ProjectClaim[];
+export interface BuildProjectMindOptions {
+    cwd?: string;
+    ownership?: OwnershipDiscoveryResult;
+    risks?: RiskDiscoveryResult;
+}
+/**
+ * Build a Project Mind from a ProjectModel (+ ownership/risk discovery).
+ * Never invents facts; preserves unknowns.
+ */
+export declare function buildProjectMind(model: ProjectModel, options?: BuildProjectMindOptions): Promise<ProjectMind>;
+export declare function buildProjectMindSync(model: ProjectModel, ownership: OwnershipDiscoveryResult, risks?: RiskDiscoveryResult): ProjectMind;

package/dist/core/understanding/mind/build.js

@@ -0,0 +1,134 @@
+import { discoverOwnership } from "../ownership/index.js";
+import { discoverRisks } from "../risks/index.js";
+import { createSnapshotIdentity } from "../snapshot/index.js";
+import { PROJECT_MIND_LIMITATIONS } from "./types.js";
+function collectUnknowns(ownership, risks, model) {
+    const unknowns = new Set();
+    for (const item of ownership.unknowns) {
+        unknowns.add(item);
+    }
+    for (const item of risks.unknowns) {
+        unknowns.add(item);
+    }
+    for (const arch of model.architectures) {
+        for (const unknown of arch.unknowns) {
+            unknowns.add(unknown);
+        }
+    }
+    if (model.domains.length === 0) {
+        unknowns.add("No domains discovered at current confidence thresholds");
+    }
+    return [...unknowns].sort((a, b) => a.localeCompare(b));
+}
+export function extractClaims(model, ownership, risks, snapshotId) {
+    const claims = [];
+    for (const domain of model.domains) {
+        claims.push({
+            id: domain.id,
+            kind: "domain",
+            subject: domain.name,
+            confidence: domain.confidence,
+            evidence: domain.evidence,
+            snapshotId,
+        });
+    }
+    for (const entry of model.entrypoints) {
+        claims.push({
+            id: entry.id,
+            kind: "entrypoint",
+            subject: entry.file,
+            confidence: entry.confidence,
+            evidence: entry.evidence,
+            snapshotId,
+        });
+    }
+    for (const dep of model.dependencies) {
+        claims.push({
+            id: dep.id,
+            kind: "dependency",
+            subject: `${dep.from}->${dep.to}`,
+            confidence: dep.confidence,
+            evidence: dep.evidence,
+            snapshotId,
+        });
+    }
+    for (const rel of model.relationships) {
+        claims.push({
+            id: rel.id,
+            kind: "relationship",
+            subject: `${rel.source}->${rel.target}:${rel.relationship}`,
+            confidence: rel.confidence,
+            evidence: rel.evidence,
+            snapshotId,
+        });
+    }
+    for (const arch of model.architectures) {
+        claims.push({
+            id: arch.id,
+            kind: "architecture",
+            subject: arch.pattern,
+            confidence: arch.confidence,
+            evidence: arch.evidence,
+            snapshotId,
+        });
+    }
+    ownership.ownerships.forEach((ownershipMatch, index) => {
+        claims.push({
+            id: `ownership_${index}_${ownershipMatch.path}`,
+            kind: "ownership",
+            subject: ownershipMatch.path,
+            confidence: ownershipMatch.confidence,
+            evidence: ownershipMatch.evidence,
+            snapshotId,
+        });
+    });
+    risks.risks.forEach((risk, index) => {
+        claims.push({
+            id: `risk_${index}_${risk.kind}_${risk.target}`,
+            kind: "risk",
+            subject: risk.target,
+            confidence: risk.confidence,
+            evidence: risk.evidence,
+            snapshotId,
+        });
+    });
+    return claims.sort((a, b) => b.confidence - a.confidence ||
+        a.kind.localeCompare(b.kind) ||
+        a.subject.localeCompare(b.subject));
+}
+/**
+ * Build a Project Mind from a ProjectModel (+ ownership/risk discovery).
+ * Never invents facts; preserves unknowns.
+ */
+export async function buildProjectMind(model, options = {}) {
+    const snapshot = createSnapshotIdentity(model);
+    const ownership = options.ownership ??
+        (await discoverOwnership(options.cwd !== undefined ? { cwd: options.cwd } : {}));
+    const risks = options.risks ?? discoverRisks(model, ownership);
+    const claims = extractClaims(model, ownership, risks, snapshot.id);
+    const unknowns = collectUnknowns(ownership, risks, model);
+    return Object.freeze({
+        snapshot,
+        model,
+        ownership,
+        risks,
+        claims: Object.freeze(claims),
+        unknowns: Object.freeze(unknowns),
+        limitations: Object.freeze([...PROJECT_MIND_LIMITATIONS]),
+    });
+}
+export function buildProjectMindSync(model, ownership, risks) {
+    const snapshot = createSnapshotIdentity(model);
+    const resolvedRisks = risks ?? discoverRisks(model, ownership);
+    const claims = extractClaims(model, ownership, resolvedRisks, snapshot.id);
+    const unknowns = collectUnknowns(ownership, resolvedRisks, model);
+    return Object.freeze({
+        snapshot,
+        model,
+        ownership,
+        risks: resolvedRisks,
+        claims: Object.freeze(claims),
+        unknowns: Object.freeze(unknowns),
+        limitations: Object.freeze([...PROJECT_MIND_LIMITATIONS]),
+    });
+}

package/dist/core/understanding/mind/index.d.ts

@@ -0,0 +1,6 @@
+export { buildProjectMind, buildProjectMindSync, extractClaims } from "./build.js";
+export { findMindClaim, findMindOwner, findMindRisks, listMindOwnership, listMindRisks, mindSummary, } from "./query.js";
+export { PROJECT_MIND_LIMITATIONS } from "./types.js";
+export type { BuildProjectMindOptions } from "./build.js";
+export type { MindClaimResult, MindOwnershipResult, MindRiskResult } from "./query.js";
+export type { ClaimKind, ProjectClaim, ProjectMind } from "./types.js";

package/dist/core/understanding/mind/index.js

@@ -0,0 +1,3 @@
+export { buildProjectMind, buildProjectMindSync, extractClaims } from "./build.js";
+export { findMindClaim, findMindOwner, findMindRisks, listMindOwnership, listMindRisks, mindSummary, } from "./query.js";
+export { PROJECT_MIND_LIMITATIONS } from "./types.js";

package/dist/core/understanding/mind/query.d.ts

@@ -0,0 +1,33 @@
+import type { OwnershipMatch } from "../ownership/types.js";
+import type { RiskMatch } from "../risks/types.js";
+import type { ProjectClaim, ProjectMind } from "./types.js";
+export interface MindOwnershipResult {
+    ownerships: readonly OwnershipMatch[];
+    count: number;
+    unknowns: readonly string[];
+}
+export interface MindRiskResult {
+    risks: readonly RiskMatch[];
+    count: number;
+    unknowns: readonly string[];
+}
+export interface MindClaimResult {
+    claim: ProjectClaim | null;
+    found: boolean;
+}
+export declare function listMindOwnership(mind: ProjectMind): MindOwnershipResult;
+export declare function listMindRisks(mind: ProjectMind): MindRiskResult;
+export declare function findMindOwner(mind: ProjectMind, filePath: string): OwnershipMatch | null;
+export declare function findMindRisks(mind: ProjectMind, target: string): RiskMatch[];
+export declare function findMindClaim(mind: ProjectMind, claimId: string): MindClaimResult;
+export declare function mindSummary(mind: ProjectMind): {
+    projectName: string;
+    snapshotId: string;
+    contentHash: string;
+    claimCount: number;
+    ownershipCount: number;
+    riskCount: number;
+    unknownCount: number;
+    topDomains: readonly string[];
+    topRisks: readonly string[];
+};

package/dist/core/understanding/mind/query.js

@@ -0,0 +1,39 @@
+import { ownersForPath } from "../ownership/index.js";
+export function listMindOwnership(mind) {
+    return {
+        ownerships: mind.ownership.ownerships,
+        count: mind.ownership.ownerships.length,
+        unknowns: mind.ownership.unknowns,
+    };
+}
+export function listMindRisks(mind) {
+    return {
+        risks: mind.risks.risks,
+        count: mind.risks.risks.length,
+        unknowns: mind.risks.unknowns,
+    };
+}
+export function findMindOwner(mind, filePath) {
+    return ownersForPath(filePath, mind.ownership.ownerships);
+}
+export function findMindRisks(mind, target) {
+    const needle = target.toLowerCase();
+    return mind.risks.risks.filter((risk) => risk.target.toLowerCase().includes(needle) || risk.kind.toLowerCase().includes(needle));
+}
+export function findMindClaim(mind, claimId) {
+    const claim = mind.claims.find((item) => item.id === claimId) ?? null;
+    return { claim, found: claim !== null };
+}
+export function mindSummary(mind) {
+    return {
+        projectName: mind.model.metadata.project.name,
+        snapshotId: mind.snapshot.id,
+        contentHash: mind.snapshot.contentHash,
+        claimCount: mind.claims.length,
+        ownershipCount: mind.ownership.ownerships.length,
+        riskCount: mind.risks.risks.length,
+        unknownCount: mind.unknowns.length,
+        topDomains: mind.model.summary.topDomains,
+        topRisks: mind.risks.risks.slice(0, 5).map((risk) => `${risk.kind}:${risk.target}`),
+    };
+}

package/dist/core/understanding/mind/types.d.ts

@@ -0,0 +1,24 @@
+import type { ProjectModel } from "../model/types.js";
+import type { OwnershipDiscoveryResult } from "../ownership/types.js";
+import type { RiskDiscoveryResult } from "../risks/types.js";
+import type { SnapshotIdentity } from "../snapshot/index.js";
+export type ClaimKind = "domain" | "entrypoint" | "dependency" | "relationship" | "architecture" | "ownership" | "risk";
+export interface ProjectClaim {
+    id: string;
+    kind: ClaimKind;
+    subject: string;
+    confidence: number;
+    evidence: readonly string[];
+    /** Snapshot that produced this claim. */
+    snapshotId: string;
+}
+export interface ProjectMind {
+    snapshot: SnapshotIdentity;
+    model: ProjectModel;
+    ownership: OwnershipDiscoveryResult;
+    risks: RiskDiscoveryResult;
+    claims: readonly ProjectClaim[];
+    unknowns: readonly string[];
+    limitations: readonly string[];
+}
+export declare const PROJECT_MIND_LIMITATIONS: readonly ["Project Mind is derived from deterministic compiler passes only", "Ownership requires explicit CODEOWNERS / MAINTAINERS / package.json evidence", "Risks describe change-danger, not vulnerability scanning", "Business rules and design intent remain unknown unless evidenced", "AI consumers must not invent repository facts beyond this representation"];

package/dist/core/understanding/mind/types.js

@@ -0,0 +1,7 @@
+export const PROJECT_MIND_LIMITATIONS = [
+    "Project Mind is derived from deterministic compiler passes only",
+    "Ownership requires explicit CODEOWNERS / MAINTAINERS / package.json evidence",
+    "Risks describe change-danger, not vulnerability scanning",
+    "Business rules and design intent remain unknown unless evidenced",
+    "AI consumers must not invent repository facts beyond this representation",
+];

package/dist/core/understanding/model/builder.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectModel, ProjectModelBuilderInput } from "./types.js";
+/**
+ * Builds a canonical immutable ProjectModel from compiler pass outputs.
+ */
+export declare class ProjectModelBuilder {
+    build(input: ProjectModelBuilderInput): ProjectModel;
+}
+/** Convenience function wrapping ProjectModelBuilder. */
+export declare function buildProjectModel(input: ProjectModelBuilderInput): ProjectModel;