@happyvertical/smrt-scanner 0.51.32 → 0.51.35

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACL,KAAK,2BAA2B,EAChC,0BAA0B,EAC1B,KAAK,0BAA0B,EAC/B,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,sBAAsB,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,KAAK,sBAAsB,GAC5B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,qCAAqC,EACrC,oBAAoB,GACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,gCAAgC,EACrC,KAAK,oBAAoB,EACzB,0BAA0B,GAC3B,MAAM,0BAA0B,CAAC"}

package/dist/inheritance-resolver.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Inheritance Resolver
+ *
+ * Resolves class inheritance chains using in-memory class map.
+ * Handles STI (Single Table Inheritance) detection and field merging.
+ */
+import type { ExternalManifest, RawClassDefinition, RawFieldDefinition, ResolvedClassDefinition } from './types.js';
+/**
+ * Resolves class inheritance chains and STI hierarchies from raw OXC scan output.
+ *
+ * After {@link OxcScanner} parses files, `InheritanceResolver` builds a
+ * class map from the raw definitions and walks each class's `extends` chain
+ * to produce fully-resolved {@link ResolvedClassDefinition} objects.
+ *
+ * Key responsibilities:
+ * - Walking extends chains across local classes and external package manifests.
+ * - Detecting which classes participate in STI (Single Table Inheritance).
+ * - Merging fields from ancestor classes for STI subclasses (base fields first).
+ * - Caching resolved chains to avoid repeated traversals.
+ *
+ * Framework base classes (`SmrtObject`, `SmrtClass`, `SmrtCollection`) are
+ * recognized without needing to appear in source files.
+ *
+ * @example
+ * ```typescript
+ * import { InheritanceResolver } from '@happyvertical/smrt-scanner';
+ *
+ * const resolver = new InheritanceResolver({ baseClasses: ['MyBaseClass'] });
+ * resolver.addClasses(rawClasses);
+ * const resolved = resolver.resolveAll();
+ * ```
+ *
+ * @see {@link OxcScanner} which owns and drives this resolver internally.
+ */
+export declare class InheritanceResolver {
+    /** Map of className -> RawClassDefinition */
+    private classMap;
+    /** External package manifests for cross-package resolution */
+    private externalManifests;
+    /** Known base classes (user-provided) */
+    private knownBaseClasses;
+    /** Cache of resolved inheritance chains */
+    private chainCache;
+    /**
+     * Create a new `InheritanceResolver`.
+     *
+     * @param options.baseClasses - Additional class names to treat as known
+     *   framework base classes (beyond the built-in `SmrtObject`, `SmrtClass`,
+     *   and `SmrtCollection`).
+     * @param options.externalManifests - Pre-loaded external package manifests
+     *   keyed by package name, used for cross-package parent class resolution.
+     */
+    constructor(options?: {
+        baseClasses?: string[];
+        externalManifests?: Map<string, ExternalManifest>;
+    });
+    /**
+     * Register raw class definitions from a scan pass.
+     *
+     * Adds each class to the internal class map by `className`.  Calling this
+     * clears the inheritance chain cache so subsequent calls to
+     * {@link resolveAll} or {@link resolveInheritanceChain} reflect the new
+     * classes.
+     *
+     * @param classes - Array of {@link RawClassDefinition} objects from
+     *   {@link ScanResults.classes}.
+     */
+    addClasses(classes: RawClassDefinition[]): void;
+    /**
+     * Register an external package manifest for cross-package base class resolution.
+     *
+     * Clears the chain cache after registration so re-resolution picks up the
+     * new definitions.
+     *
+     * @param manifest - External package manifest providing class definitions
+     *   that may appear as base classes in the local project.
+     *
+     * @see {@link ExternalManifest}
+     */
+    addExternalManifest(manifest: ExternalManifest): void;
+    /**
+     * Resolve all registered classes and return fully-resolved definitions.
+     *
+     * A class is included in the output if it either:
+     * 1. Has an `@smrt()` decorator, or
+     * 2. Directly or transitively extends a framework base class
+     *    (`SmrtObject`, `SmrtClass`, `SmrtCollection`) — this captures
+     *    collection classes such as `class MeetingCollection extends
+     *    SmrtCollection<Meeting>` that do not carry `@smrt()` themselves.
+     *
+     * @returns An array of {@link ResolvedClassDefinition} — one entry per
+     *   eligible class, with inheritance chain, STI metadata, and merged fields
+     *   populated.
+     *
+     * @see {@link resolve} to resolve a single class definition.
+     */
+    resolveAll(): ResolvedClassDefinition[];
+    /**
+     * Check if a class extends a framework base class
+     * (SmrtObject, SmrtClass, or SmrtCollection)
+     */
+    private extendsFrameworkBase;
+    /**
+     * Resolve a single raw class definition into a fully-resolved definition.
+     *
+     * Computes the inheritance chain, determines the effective table strategy,
+     * detects STI membership, and merges ancestor fields for STI classes.
+     *
+     * @param classDef - The raw class definition to resolve.
+     * @returns A {@link ResolvedClassDefinition} with all inherited metadata
+     *   applied.  The `packageName` field is left as `null` and must be set by
+     *   the caller (e.g. {@link ManifestAdapter}).
+     *
+     * @see {@link resolveAll} to resolve every registered class at once.
+     */
+    resolve(classDef: RawClassDefinition): ResolvedClassDefinition;
+    /**
+     * Resolve the full inheritance chain for a named class, from the root base
+     * class down to the named class itself.
+     *
+     * Results are memoised in an internal cache that is cleared whenever
+     * {@link addClasses} or {@link addExternalManifest} is called.
+     *
+     * @param className - Name of the class to resolve.
+     * @returns An ordered array of class names starting from the furthest
+     *   ancestor and ending with `className`.
+     *
+     * @example
+     * ```typescript
+     * // Given: class Article extends Content, class Content extends SmrtObject
+     * resolver.resolveInheritanceChain('Article');
+     * // => ['SmrtObject', 'Content', 'Article']
+     * ```
+     */
+    resolveInheritanceChain(className: string): string[];
+    /**
+     * Look up a class definition by name, searching in priority order:
+     * 1. Local classes added via {@link addClasses}.
+     * 2. External package manifests added via {@link addExternalManifest}.
+     * 3. Built-in framework base classes (`SmrtObject`, `SmrtClass`,
+     *    `SmrtCollection`) — returns a minimal stub definition so chain walking
+     *    can terminate cleanly.
+     *
+     * @param className - Class name to look up.
+     * @returns The {@link RawClassDefinition} if found, or `null` if the class
+     *   is unknown to the resolver.
+     */
+    findClassDefinition(className: string): RawClassDefinition | null;
+    /**
+     * Find the STI root class in a resolved inheritance chain.
+     *
+     * Walks the chain from base to leaf and returns the name of the first class
+     * whose `@smrt()` decorator explicitly declares `tableStrategy: 'sti'`.
+     *
+     * @param chain - Ordered inheritance chain (base → leaf) as returned by
+     *   {@link resolveInheritanceChain}.
+     * @returns The class name of the STI root, or `null` if no class in the
+     *   chain uses `tableStrategy: 'sti'`.
+     */
+    findSTIBase(chain: string[]): string | null;
+    /**
+     * Determine the effective table strategy (`'sti'` or `'cti'`) for a class.
+     *
+     * Resolution order:
+     * 1. The class's own `@smrt({ tableStrategy })` declaration, if present.
+     * 2. The nearest ancestor that declares `tableStrategy: 'sti'` — STI is
+     *    inherited automatically by all subclasses.
+     * 3. Defaults to `'cti'` if no STI ancestor is found.
+     *
+     * @param classDef - Raw class definition whose strategy is being determined.
+     * @param chain - Pre-resolved inheritance chain for `classDef` (base → leaf).
+     * @returns `'sti'` or `'cti'`.
+     */
+    determineTableStrategy(classDef: RawClassDefinition, chain: string[]): 'sti' | 'cti';
+    /**
+     * Merge fields from all classes in an STI inheritance chain.
+     *
+     * Iterates from the root base class to the leaf class so that base class
+     * fields appear first in the returned array.  If a field name is declared in
+     * both an ancestor and a descendant, the ancestor's definition takes
+     * precedence (first-seen wins), preserving the base-class column layout.
+     *
+     * @param chain - Ordered inheritance chain (base → leaf) as returned by
+     *   {@link resolveInheritanceChain}.
+     * @returns A deduplicated, ordered array of {@link RawFieldDefinition}
+     *   covering every field in the STI hierarchy.
+     */
+    mergeFieldsForSTI(chain: string[]): RawFieldDefinition[];
+    /**
+     * Return all known descendants of a class.
+     *
+     * Useful for STI schema generation where the base table must accommodate
+     * columns from every subclass.
+     *
+     * @param className - The ancestor class name to search from.
+     * @returns An array of class names (local classes only) whose resolved
+     *   inheritance chain includes `className`.  Does not include `className`
+     *   itself.
+     */
+    getDescendants(className: string): string[];
+    /**
+     * Check whether a class participates in an STI hierarchy.
+     *
+     * @param className - Name of the class to check.
+     * @returns `true` if any class in the resolved inheritance chain declares
+     *   `tableStrategy: 'sti'`, `false` otherwise.
+     */
+    isSTIClass(className: string): boolean;
+    /**
+     * Return aggregate statistics about the classes registered with this resolver.
+     *
+     * @returns An object with:
+     *   - `totalClasses` — total number of classes in the class map.
+     *   - `smrtClasses` — classes that carry `@smrt()`.
+     *   - `stiClasses` — `@smrt()` classes in an STI hierarchy.
+     *   - `maxInheritanceDepth` — length of the deepest inheritance chain among
+     *     `@smrt()` classes.
+     */
+    getStats(): {
+        totalClasses: number;
+        smrtClasses: number;
+        stiClasses: number;
+        maxInheritanceDepth: number;
+    };
+}
+//# sourceMappingURL=inheritance-resolver.d.ts.map

package/dist/inheritance-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritance-resolver.d.ts","sourceRoot":"","sources":["../src/inheritance-resolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAiCpB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,mBAAmB;IAC9B,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAA8C;IAE9D,8DAA8D;IAC9D,OAAO,CAAC,iBAAiB,CAA4C;IAErE,yCAAyC;IACzC,OAAO,CAAC,gBAAgB,CAAc;IAEtC,2CAA2C;IAC3C,OAAO,CAAC,UAAU,CAAoC;IAEtD;;;;;;;;OAQG;gBAED,OAAO,GAAE;QACP,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QACvB,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;KAC9C;IASR;;;;;;;;;;OAUG;IACH,UAAU,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,IAAI;IAQ/C;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAKrD;;;;;;;;;;;;;;;OAeG;IACH,UAAU,IAAI,uBAAuB,EAAE;IAgBvC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,EAAE,kBAAkB,GAAG,uBAAuB;IAiC9D;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IA6BpD;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IA+BjE;;;;;;;;;;OAUG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI;IAU3C;;;;;;;;;;;;OAYG;IACH,sBAAsB,CACpB,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,MAAM,EAAE,GACd,KAAK,GAAG,KAAK;IAmBhB;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,kBAAkB,EAAE;IAoBxD;;;;;;;;;;OAUG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAe3C;;;;;;OAMG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAKtC;;;;;;;;;OASG;IACH,QAAQ,IAAI;QACV,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,mBAAmB,EAAE,MAAM,CAAC;KAC7B;CAyBF"}

package/dist/knowledge-discovery.d.ts

@@ -0,0 +1,48 @@
+import type { DomainKnowledgeModuleDoc } from '@happyvertical/smrt-types';
+export interface ScopedPackageDirectory {
+    /** Scope entry name; consumers may select by alias rather than manifest name. */
+    name: string;
+    /** Original node_modules path, retained for workspace-relative reporting. */
+    directory: string;
+    /** Resolved path for identity comparisons or absolute snapshot links. */
+    realDirectory: string;
+}
+/**
+ * Enumerate scope entries without descending into pnpm's linked dependency graph.
+ * Selection, workspace discovery and enrichment remain caller policies.
+ */
+export declare function discoverScopedPackageDirectories(scopeDirectories: string[]): ScopedPackageDirectory[];
+/** Read authored docs only; never load artifacts, package code or object scans. */
+export declare function readPackageAgentDoc(directory: string, options?: {
+    inspectAdapter?: boolean;
+}): {
+    hasAgentsMd: boolean;
+    hasClaudeMd: boolean;
+    hasClaudeShim: boolean;
+    agentsContent: string;
+    claudeContent: string;
+    source: "AGENTS.md" | "CLAUDE.md" | null;
+    content: string | null;
+};
+/** `sourceHashes` key prefix for a linked module doc, e.g. `moduleDoc:agents/crm.md`. */
+export declare const MODULE_DOC_HASH_PREFIX = "moduleDoc:";
+/**
+ * `sourceHashes` key prefix for a module declaring a view intent or playbook,
+ * e.g. `agentSurface:src/lib/orders.intents.ts` (#2591).
+ */
+export declare const AGENT_SURFACE_HASH_PREFIX = "agentSurface:";
+/**
+ * Module doc paths linked from a package's `AGENTS.md`, relative to the package
+ * root and in document order.
+ *
+ * Instruction chains are additive (see `scripts/check-agents-chain.mjs`), so an
+ * oversized package doc is split into `packages/<pkg>/agents/<module>.md` siblings
+ * instead of nested `AGENTS.md` files. Only links resolving to an existing file
+ * INSIDE the package are accepted — a cross-package reference such as
+ * `packages/affiliates/MIGRATION.md` belongs to that package's own chain and is
+ * ignored here.
+ */
+export declare function resolveAgentModuleDocPaths(rootDir: string, agentDoc: string | undefined): string[];
+/** {@link resolveAgentModuleDocPaths}, with each doc's contents read. */
+export declare function readAgentModuleDocs(rootDir: string, agentDoc: string | undefined): DomainKnowledgeModuleDoc[];
+//# sourceMappingURL=knowledge-discovery.d.ts.map

package/dist/knowledge-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-discovery.d.ts","sourceRoot":"","sources":["../src/knowledge-discovery.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAE1E,MAAM,WAAW,sBAAsB;IACrC,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,gBAAgB,EAAE,MAAM,EAAE,GACzB,sBAAsB,EAAE,CAwB1B;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO;;;;;;;;EA0B3C;AAWD,yFAAyF;AACzF,eAAO,MAAM,sBAAsB,eAAe,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,kBAAkB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,EAAE,CAgBV;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,wBAAwB,EAAE,CAM5B"}

package/dist/knowledge-graph.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Cross-package knowledge graph (#2863).
+ *
+ * Each package's own `smrt-knowledge.json` (see `knowledge.ts`) is a
+ * per-package projection. Nothing merges them, so cross-package invariants
+ * that the scanner manifest already carries — `@crossPackageRef` targets, STI
+ * parent/child pairs, junction/hierarchical/polymorphic base usage, and
+ * `_smrt_` system-table ownership — live only as prose in the root
+ * `AGENTS.md`. This module builds the merged, deterministic root artifact
+ * (`.smrt/smrt-knowledge-graph.json`) from whichever per-package artifacts
+ * are present, and checks it for staleness the same way `knowledge.ts` checks
+ * a package artifact: by comparing recorded `sourceHashes` against the
+ * current file content.
+ *
+ * This module never invents an edge: every edge is a direct read of a field
+ * already emitted into a package's `DomainKnowledgeManifest` (`related`,
+ * `tableStrategy`, `extends`, `relationshipFeatures`, `tableName`).
+ */
+import type { DomainKnowledgeManifest } from '@happyvertical/smrt-types';
+/**
+ * Discovers every currently-buildable per-package artifact path under
+ * `<rootDir>/packages/*`, preferring the published `dist/smrt-knowledge.json`
+ * over the local dev `.smrt/smrt-knowledge.json` when both exist. Shared by
+ * the generator (which needs the manifest content) and the freshness check
+ * (which only needs to know whether the current SET of artifacts matches
+ * what the graph was built from — a newly built package, or a package that
+ * newly started exporting `./smrt-knowledge.json`, must mark the graph stale
+ * even though every artifact the graph already knows about is unchanged).
+ */
+export declare function discoverKnowledgeArtifactPaths(rootDir: string): string[];
+/** One package's `smrt-knowledge.json`, located relative to the graph root. */
+export interface KnowledgeGraphInput {
+    /** Path to the artifact, relative to the repo root, POSIX-separated. */
+    artifactPath: string;
+    manifest: DomainKnowledgeManifest;
+}
+export interface KnowledgeGraphPackageNode {
+    name: string;
+    version?: string;
+    artifactPath: string;
+    tags: string[];
+    risks: string[];
+    summary?: string;
+    objectCount: number;
+}
+export interface KnowledgeGraphObjectNode {
+    /** `<packageName>#<qualifiedName-or-name>`, this graph's stable object id. */
+    id: string;
+    packageName: string;
+    name: string;
+    qualifiedName?: string;
+    collection: string;
+    tableName?: string;
+    tableStrategy?: 'cti' | 'sti';
+    extends?: string;
+}
+export type KnowledgeGraphEdgeType = 'crossPackageRef' | 'sti' | 'junction' | 'hierarchical' | 'polymorphic' | 'systemTable';
+export interface KnowledgeGraphEdge {
+    type: KnowledgeGraphEdgeType;
+    /** Object id (or `<packageName>#<extends>`-style unresolved target) this edge starts from. */
+    from: string;
+    /**
+     * Object id the edge points to when resolvable against a scanned object;
+     * otherwise the raw declared target (e.g. a qualified name this run did
+     * not scan), so the edge is still readable rather than dropped.
+     */
+    to?: string;
+    /** Declaring field name, for `crossPackageRef` edges. */
+    field?: string;
+}
+export interface SmrtKnowledgeGraph {
+    schemaVersion: 1;
+    generatedAt: string;
+    /** `artifactPath -> sha256(content)`, sorted by key; the freshness input. */
+    sourceHashes: Record<string, string>;
+    packages: KnowledgeGraphPackageNode[];
+    objects: KnowledgeGraphObjectNode[];
+    edges: KnowledgeGraphEdge[];
+}
+export interface BuildKnowledgeGraphOptions {
+    /**
+     * The graph currently on disk, when regenerating. `generatedAt` is
+     * preserved from it rather than reset to the clock whenever the rebuilt
+     * graph is otherwise semantically identical — the same pattern
+     * `preserveKnowledgeGeneratedAt` uses for per-package artifacts
+     * (`packages/core/src/vite-plugin/index.ts`) — so re-running the generator
+     * with nothing merged actually changed does not churn the file (#2872
+     * review).
+     */
+    previousGraph?: SmrtKnowledgeGraph;
+}
+/** Builds the merged graph. Deterministic: every array is sorted. */
+export declare function buildKnowledgeGraph(inputs: KnowledgeGraphInput[], options?: BuildKnowledgeGraphOptions): SmrtKnowledgeGraph;
+/** Deterministic `JSON.stringify` — object keys are sorted at every level. */
+export declare function stableStringify(value: unknown): string;
+export interface KnowledgeGraphFreshnessIssue {
+    severity: 'error' | 'warning';
+    code: 'missing-knowledge-graph' | 'stale-knowledge-graph' | 'knowledge-graph-source-missing';
+    message: string;
+    file?: string;
+}
+/**
+ * Checks the merged graph's recorded `sourceHashes` against the current
+ * content of each per-package artifact it was built from — the same pattern
+ * `knowledge.ts`/`smrt-dev-mcp` use for a single package's `sourceHashes`.
+ *
+ * `graphPath` and each `artifactPath` in the graph are resolved relative to
+ * `rootDir` (the repo root).
+ */
+export declare function checkKnowledgeGraphFreshness(rootDir: string, graphPath: string, options?: {
+    requireArtifact?: boolean;
+}): KnowledgeGraphFreshnessIssue[];
+//# sourceMappingURL=knowledge-graph.d.ts.map

package/dist/knowledge-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-graph.d.ts","sourceRoot":"","sources":["../src/knowledge-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EACV,uBAAuB,EAExB,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAexE;AAED,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,uBAAuB,CAAC;CACnC;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,8EAA8E;IAC9E,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,sBAAsB,GAC9B,iBAAiB,GACjB,KAAK,GACL,UAAU,GACV,cAAc,GACd,aAAa,GACb,aAAa,CAAC;AAElB,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,8FAA8F;IAC9F,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,CAAC,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,EAAE,yBAAyB,EAAE,CAAC;IACtC,OAAO,EAAE,wBAAwB,EAAE,CAAC;IACpC,KAAK,EAAE,kBAAkB,EAAE,CAAC;CAC7B;AAUD,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,mBAAmB,EAAE,EAC7B,OAAO,GAAE,0BAA+B,GACvC,kBAAkB,CAoKpB;AAOD,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD;AA+BD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,IAAI,EACA,yBAAyB,GACzB,uBAAuB,GACvB,gCAAgC,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,4BAA4B,EAAE,CA0FhC"}

package/dist/knowledge.d.ts

@@ -0,0 +1,3 @@
+export { AGENT_SURFACE_HASH_PREFIX, discoverScopedPackageDirectories, MODULE_DOC_HASH_PREFIX, readAgentModuleDocs, readPackageAgentDoc, resolveAgentModuleDocPaths, type ScopedPackageDirectory, } from './knowledge-discovery.js';
+export { type BuildKnowledgeGraphOptions, buildKnowledgeGraph, checkKnowledgeGraphFreshness, discoverKnowledgeArtifactPaths, type KnowledgeGraphEdge, type KnowledgeGraphEdgeType, type KnowledgeGraphFreshnessIssue, type KnowledgeGraphInput, type KnowledgeGraphObjectNode, type KnowledgeGraphPackageNode, type SmrtKnowledgeGraph, stableStringify, } from './knowledge-graph.js';
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge.d.ts","sourceRoot":"","sources":["../src/knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,0BAA0B,EAC/B,mBAAmB,EACnB,4BAA4B,EAC5B,8BAA8B,EAC9B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EACjC,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,eAAe,GAChB,MAAM,sBAAsB,CAAC"}