skillroute 0.4.3

package/node_modules/@skillroute/core/dist/db/schema.js

@@ -0,0 +1,77 @@
+export const schemaVersion = 3;
+export const schemaSql = [
+    `CREATE TABLE IF NOT EXISTS skills (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    description TEXT,
+    root_path TEXT NOT NULL,
+    canonical_path TEXT,
+    source_type TEXT NOT NULL,
+    provenance_json TEXT,
+    paths_json TEXT,
+    implicit_invocation INTEGER,
+    self_contained INTEGER,
+    trust_level TEXT,
+    content_hash TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS resources (
+    id TEXT PRIMARY KEY,
+    skill_id TEXT NOT NULL,
+    resource_type TEXT NOT NULL,
+    path TEXT NOT NULL,
+    is_external INTEGER NOT NULL,
+    content_hash TEXT,
+    FOREIGN KEY(skill_id) REFERENCES skills(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS methods (
+    id TEXT PRIMARY KEY,
+    skill_id TEXT NOT NULL,
+    method_name TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    trigger_terms_json TEXT NOT NULL,
+    inputs_json TEXT NOT NULL,
+    outputs_json TEXT NOT NULL,
+    required_tools_json TEXT NOT NULL,
+    start_section INTEGER NOT NULL,
+    end_section INTEGER NOT NULL,
+    extraction_confidence REAL NOT NULL,
+    FOREIGN KEY(skill_id) REFERENCES skills(id) ON DELETE CASCADE
+  )`,
+    `CREATE VIRTUAL TABLE IF NOT EXISTS skill_search_fts USING fts5(
+    skill_id UNINDEXED,
+    name,
+    description,
+    body,
+    headings,
+    method_summary,
+    tokenize = 'unicode61'
+  )`,
+    `CREATE TABLE IF NOT EXISTS provider_installs (
+    id TEXT PRIMARY KEY,
+    skill_id TEXT NOT NULL,
+    provider_name TEXT NOT NULL,
+    install_path TEXT NOT NULL,
+    projection_strategy TEXT NOT NULL,
+    content_hash TEXT,
+    drift INTEGER NOT NULL DEFAULT 0,
+    last_sync_at TEXT,
+    FOREIGN KEY(skill_id) REFERENCES skills(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS runtime_state (
+    key TEXT PRIMARY KEY,
+    value_json TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+];
+export const sqlitePragmas = [
+    "PRAGMA journal_mode = WAL",
+    "PRAGMA busy_timeout = 5000",
+    "PRAGMA synchronous = NORMAL",
+    "PRAGMA foreign_keys = ON",
+];
+//# sourceMappingURL=schema.js.map

package/node_modules/@skillroute/core/dist/db/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC;AAE/B,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB;;;;;;;;;;;;;;IAcE;IACF;;;;;;;;IAQE;IACF;;;;;;;;;;;;;IAaE;IACF;;;;;;;;IAQE;IACF;;;;;;;;;;IAUE;IACF;;;IAGE;IACF;;;;IAIE;CACH,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,2BAA2B;IAC3B,4BAA4B;IAC5B,6BAA6B;IAC7B,0BAA0B;CAC3B,CAAC"}

package/node_modules/@skillroute/core/dist/dedup/dedup.d.ts

@@ -0,0 +1,6 @@
+import type { DedupResult, ParsedSkill } from "../types.js";
+export interface DedupOptions {
+    threshold?: number;
+}
+export declare function dedupSkills(skills: ParsedSkill[], options?: DedupOptions): DedupResult;
+//# sourceMappingURL=dedup.d.ts.map

package/node_modules/@skillroute/core/dist/dedup/dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.d.ts","sourceRoot":"","sources":["../../src/dedup/dedup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAGxE,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,OAAO,GAAE,YAAiB,GAAG,WAAW,CAwC1F"}

package/node_modules/@skillroute/core/dist/dedup/dedup.js

@@ -0,0 +1,43 @@
+import { jaccardSimilarity, tokenizeText } from "./similarity.js";
+export function dedupSkills(skills, options = {}) {
+    const threshold = options.threshold ?? 0.85;
+    const matches = [];
+    for (let i = 0; i < skills.length; i += 1) {
+        for (let j = i + 1; j < skills.length; j += 1) {
+            const left = skills[i];
+            const right = skills[j];
+            if (left.contentHash === right.contentHash) {
+                matches.push(match(left, right, "content_hash", 1));
+                continue;
+            }
+            if (left.name.toLowerCase() === right.name.toLowerCase()) {
+                matches.push(match(left, right, "name", 1));
+                continue;
+            }
+            const score = jaccardSimilarity(tokenizeText(`${left.name} ${left.description}`), tokenizeText(`${right.name} ${right.description}`));
+            if (score >= threshold) {
+                matches.push(match(left, right, "name_description", score));
+                continue;
+            }
+            const leftMethodText = methodSummaryText(left);
+            const rightMethodText = methodSummaryText(right);
+            const methodScore = leftMethodText && rightMethodText ? jaccardSimilarity(tokenizeText(leftMethodText), tokenizeText(rightMethodText)) : 0;
+            if (methodScore >= threshold) {
+                matches.push(match(left, right, "method_summary", methodScore));
+            }
+        }
+    }
+    return { matches };
+}
+function match(left, right, signal, score) {
+    return {
+        leftPath: left.rootPath,
+        rightPath: right.rootPath,
+        signal,
+        score,
+    };
+}
+function methodSummaryText(skill) {
+    return skill.methodSummaries.map((summary) => `${summary.methodName} ${summary.summary}`).join(" ");
+}
+//# sourceMappingURL=dedup.js.map

package/node_modules/@skillroute/core/dist/dedup/dedup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.js","sourceRoot":"","sources":["../../src/dedup/dedup.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAMlE,MAAM,UAAU,WAAW,CAAC,MAAqB,EAAE,UAAwB,EAAE;IAC3E,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC;IAC5C,MAAM,OAAO,GAAiB,EAAE,CAAC;IAEjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;YACxB,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;YAEzB,IAAI,IAAI,CAAC,WAAW,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC3C,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC;gBACpD,SAAS;YACX,CAAC;YAED,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;gBACzD,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC5C,SAAS;YACX,CAAC;YAED,MAAM,KAAK,GAAG,iBAAiB,CAC7B,YAAY,CAAC,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,EAChD,YAAY,CAAC,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,CACnD,CAAC;YAEF,IAAI,KAAK,IAAI,SAAS,EAAE,CAAC;gBACvB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,CAAC,CAAC,CAAC;gBAC5D,SAAS;YACX,CAAC;YAED,MAAM,cAAc,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC/C,MAAM,eAAe,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;YACjD,MAAM,WAAW,GACf,cAAc,IAAI,eAAe,CAAC,CAAC,CAAC,iBAAiB,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACzH,IAAI,WAAW,IAAI,SAAS,EAAE,CAAC;gBAC7B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,CAAC,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,CAAC;AACrB,CAAC;AAED,SAAS,KAAK,CACZ,IAAiB,EACjB,KAAkB,EAClB,MAA4B,EAC5B,KAAa;IAEb,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,SAAS,EAAE,KAAK,CAAC,QAAQ;QACzB,MAAM;QACN,KAAK;KACN,CAAC;AACJ,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAkB;IAC3C,OAAO,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACtG,CAAC"}

package/node_modules/@skillroute/core/dist/dedup/similarity.d.ts

@@ -0,0 +1,3 @@
+export declare function tokenizeText(input: string): Set<string>;
+export declare function jaccardSimilarity(left: Set<string>, right: Set<string>): number;
+//# sourceMappingURL=similarity.d.ts.map

package/node_modules/@skillroute/core/dist/dedup/similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.d.ts","sourceRoot":"","sources":["../../src/dedup/similarity.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAQvD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,CAa/E"}

package/node_modules/@skillroute/core/dist/dedup/similarity.js

@@ -0,0 +1,20 @@
+export function tokenizeText(input) {
+    return new Set(input
+        .toLowerCase()
+        .split(/[^a-z0-9\u4e00-\u9fff]+/u)
+        .map((token) => token.trim())
+        .filter(Boolean));
+}
+export function jaccardSimilarity(left, right) {
+    if (left.size === 0 && right.size === 0) {
+        return 1;
+    }
+    let intersection = 0;
+    for (const token of left) {
+        if (right.has(token)) {
+            intersection += 1;
+        }
+    }
+    return intersection / (left.size + right.size - intersection);
+}
+//# sourceMappingURL=similarity.js.map

package/node_modules/@skillroute/core/dist/dedup/similarity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.js","sourceRoot":"","sources":["../../src/dedup/similarity.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,OAAO,IAAI,GAAG,CACZ,KAAK;SACF,WAAW,EAAE;SACb,KAAK,CAAC,0BAA0B,CAAC;SACjC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;SAC5B,MAAM,CAAC,OAAO,CAAC,CACnB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAiB,EAAE,KAAkB;IACrE,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QACxC,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE,CAAC;QACzB,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,YAAY,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,YAAY,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC;AAChE,CAAC"}

package/node_modules/@skillroute/core/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class SkillRouteError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, options?: {
+        retryable?: boolean;
+        cause?: unknown;
+    });
+}
+export declare function toErrorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/@skillroute/core/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;gBAEhB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO;CAMlG;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAErD"}

package/node_modules/@skillroute/core/dist/errors.js

@@ -0,0 +1,14 @@
+export class SkillRouteError extends Error {
+    code;
+    retryable;
+    constructor(code, message, options = {}) {
+        super(message, { cause: options.cause });
+        this.name = "SkillRouteError";
+        this.code = code;
+        this.retryable = options.retryable ?? false;
+    }
+}
+export function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=errors.js.map

package/node_modules/@skillroute/core/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAS;IACb,SAAS,CAAU;IAE5B,YAAY,IAAY,EAAE,OAAe,EAAE,UAAoD,EAAE;QAC/F,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC;IAC9C,CAAC;CACF;AAED,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC"}

package/node_modules/@skillroute/core/dist/graph/skill-graph.d.ts

@@ -0,0 +1,16 @@
+import type { SkillGraphChain, SkillGraphNeighbor, SkillGraphNode, SkillGraphResult } from "../types.js";
+export interface SkillGraphOptions {
+    maxDepth?: number;
+    maxPaths?: number;
+    includeExternal?: boolean;
+}
+export declare function buildSkillGraph(scanRoot: string, options?: SkillGraphOptions): Promise<SkillGraphResult>;
+export declare function resolveSkillGraphNode(graph: SkillGraphResult, target: string): {
+    id: string;
+    node: SkillGraphNode;
+} | null;
+export declare function referencesBy(graph: SkillGraphResult, target: string): SkillGraphNeighbor[];
+export declare function neighbors(graph: SkillGraphResult, target: string): SkillGraphNeighbor[];
+export declare function pathToSkill(graph: SkillGraphResult, target: string): SkillGraphNode[];
+export declare function skillChain(graph: SkillGraphResult, target: string): SkillGraphChain | null;
+//# sourceMappingURL=skill-graph.d.ts.map

package/node_modules/@skillroute/core/dist/graph/skill-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-graph.d.ts","sourceRoot":"","sources":["../../src/graph/skill-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,eAAe,EAEf,kBAAkB,EAClB,cAAc,EAEd,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAYD,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmDlH;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAAG,IAAI,CAa1H;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAW1F;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAiBvF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,CAiBrF;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAa1F"}

package/node_modules/@skillroute/core/dist/graph/skill-graph.js

@@ -0,0 +1,433 @@
+import { access } from "node:fs/promises";
+import { dirname, join, normalize, relative, resolve } from "node:path";
+import { sha256 } from "../hash.js";
+import { parseSkillGraphEntry } from "../parser/skill-parser.js";
+import { findSkillDirectories } from "../scan/scan.js";
+const DEFAULT_MAX_DEPTH = 32;
+const DEFAULT_MAX_PATHS = 1_000;
+export async function buildSkillGraph(scanRoot, options = {}) {
+    const root = resolve(scanRoot);
+    const maxDepth = normalizeMaxDepth(options.maxDepth);
+    const maxPaths = normalizeMaxPaths(options.maxPaths);
+    const includeExternal = options.includeExternal ?? true;
+    const warnings = [];
+    const nodes = new Map();
+    const edges = [];
+    const skillRoots = await findSkillDirectories(root);
+    const parsedSkills = await parseSkills(root, skillRoots, warnings);
+    const skillByRoot = new Map(parsedSkills.map((entry) => [normalizePath(entry.rootPath), entry]));
+    const scanRootSkill = skillByRoot.get(normalizePath(root));
+    const rootId = scanRootSkill ? skillId(scanRootSkill.rootPath) : `scan_root:${sha256(root)}`;
+    nodes.set(rootId, {
+        id: rootId,
+        kind: scanRootSkill ? "skill" : "scan_root",
+        path: root,
+        relativePath: ".",
+        depth: 0,
+        name: scanRootSkill?.skill.name,
+    });
+    for (const entry of parsedSkills) {
+        const id = skillId(entry.rootPath);
+        if (id === rootId) {
+            continue;
+        }
+        nodes.set(id, skillNode(entry));
+    }
+    addHierarchyEdges(rootId, parsedSkills, skillByRoot, edges);
+    for (const entry of parsedSkills) {
+        await addResourceEdges(root, entry, parsedSkills, nodes, edges, warnings, includeExternal);
+    }
+    markReferenceCycles(edges, nodes, warnings);
+    const enumeration = enumeratePaths(rootId, nodes, edges, maxDepth, maxPaths, warnings);
+    const sortedNodes = Array.from(nodes.values()).sort(compareNodes);
+    return {
+        root,
+        scanRootIsSkill: Boolean(scanRootSkill),
+        nodes: sortedNodes,
+        edges: finalizeEdges(edges, nodes),
+        paths: enumeration.paths,
+        warnings,
+        truncated: enumeration.truncated,
+    };
+}
+export function resolveSkillGraphNode(graph, target) {
+    const normalizedTarget = normalizePath(target);
+    const lowerTarget = target.toLowerCase();
+    const pathMatch = graph.nodes.find((candidate) => candidate.id === target
+        || normalizePath(candidate.relativePath) === normalizedTarget
+        || normalizePath(candidate.path) === normalizedTarget);
+    if (pathMatch) {
+        return { id: pathMatch.id, node: pathMatch };
+    }
+    const node = graph.nodes.find((candidate) => candidate.kind === "skill" && candidate.name?.toLowerCase() === lowerTarget);
+    return node ? { id: node.id, node } : null;
+}
+export function referencesBy(graph, target) {
+    const resolved = resolveSkillGraphNode(graph, target);
+    if (!resolved) {
+        return [];
+    }
+    const nodes = nodeMap(graph);
+    return activeEdges(graph)
+        .filter((edge) => edge.to === resolved.id && (edge.kind === "references" || edge.kind === "references_skill"))
+        .map((edge) => neighbor(nodes, edge, "incoming"))
+        .filter((item) => Boolean(item))
+        .sort(compareNeighbors);
+}
+export function neighbors(graph, target) {
+    const resolved = resolveSkillGraphNode(graph, target);
+    if (!resolved) {
+        return [];
+    }
+    const nodes = nodeMap(graph);
+    return activeEdges(graph)
+        .flatMap((edge) => {
+        if (edge.from === resolved.id) {
+            return neighbor(nodes, edge, "outgoing") ?? [];
+        }
+        if (edge.to === resolved.id) {
+            return neighbor(nodes, edge, "incoming") ?? [];
+        }
+        return [];
+    })
+        .sort(compareNeighbors);
+}
+export function pathToSkill(graph, target) {
+    const resolved = resolveSkillGraphNode(graph, target);
+    if (!resolved) {
+        return [];
+    }
+    const nodes = nodeMap(graph);
+    const matching = graph.paths
+        .map((path) => {
+        const index = path.nodes.indexOf(resolved.id);
+        return index >= 0 ? path.nodes.slice(0, index + 1) : [];
+    })
+        .filter((path) => path.length > 0)
+        .sort((left, right) => left.length - right.length)[0];
+    if (!matching) {
+        return [resolved.node];
+    }
+    return matching.map((id) => nodes.get(id)).filter((node) => Boolean(node));
+}
+export function skillChain(graph, target) {
+    const resolved = resolveSkillGraphNode(graph, target);
+    if (!resolved) {
+        return null;
+    }
+    const allNeighbors = neighbors(graph, resolved.id);
+    return {
+        target: resolved.node,
+        references: allNeighbors.filter((item) => item.direction === "outgoing" && item.edge.kind === "references_skill"),
+        referencedBy: referencesBy(graph, resolved.id),
+        containmentPath: pathToSkill(graph, resolved.id).filter((node) => node.kind === "scan_root" || node.kind === "skill"),
+        resources: allNeighbors.filter((item) => item.direction === "outgoing" && item.edge.kind === "references"),
+    };
+}
+async function parseSkills(root, skillRoots, warnings) {
+    const results = await Promise.allSettled(skillRoots.map(async (skillRoot) => {
+        const resolvedRoot = resolve(skillRoot);
+        const skill = await parseSkillGraphEntry(resolvedRoot);
+        const rel = relativePath(root, resolvedRoot);
+        return {
+            rootPath: resolvedRoot,
+            relativePath: rel,
+            depth: pathDepth(rel),
+            skill,
+        };
+    }));
+    const parsed = [];
+    results.forEach((result, index) => {
+        if (result.status === "fulfilled") {
+            parsed.push(result.value);
+            return;
+        }
+        warnings.push(`${skillRoots[index] ?? "unknown"}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+    });
+    return parsed.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+function addHierarchyEdges(rootId, parsedSkills, skillByRoot, edges) {
+    for (const entry of parsedSkills) {
+        const id = skillId(entry.rootPath);
+        if (id === rootId) {
+            continue;
+        }
+        const parent = nearestSkillAncestor(entry.rootPath, skillByRoot);
+        edges.push({
+            from: parent ? skillId(parent.rootPath) : rootId,
+            to: id,
+            kind: "contains",
+        });
+    }
+}
+async function addResourceEdges(root, entry, parsedSkills, nodes, edges, warnings, includeExternal) {
+    const from = skillId(entry.rootPath);
+    for (const resource of entry.skill.resources) {
+        if (resource.isExternal) {
+            if (!includeExternal) {
+                continue;
+            }
+            const id = `external:${sha256(resource.path)}`;
+            nodes.set(id, {
+                id,
+                kind: "external",
+                path: resource.path,
+                relativePath: resource.path,
+                depth: entry.depth + 1,
+            });
+            edges.push({
+                from,
+                to: id,
+                kind: "references",
+                via: resource.mentionedBy,
+                rawPath: resource.path,
+                resolvedPath: resource.path,
+                external: true,
+            });
+            continue;
+        }
+        const resolvedPath = resolveLocalResource(entry.rootPath, resource);
+        const targetSkill = referencedSkill(resolvedPath, parsedSkills);
+        if (targetSkill && normalizePath(targetSkill.rootPath) !== normalizePath(entry.rootPath)) {
+            edges.push({
+                from,
+                to: skillId(targetSkill.rootPath),
+                kind: "references_skill",
+                via: resource.mentionedBy,
+                rawPath: resource.path,
+                resolvedPath,
+            });
+            continue;
+        }
+        const id = `resource:${sha256(resolvedPath)}`;
+        const resourceRelativePath = relativePath(root, resolvedPath);
+        nodes.set(id, {
+            id,
+            kind: "resource",
+            path: resolvedPath,
+            relativePath: resourceRelativePath,
+            depth: pathDepth(resourceRelativePath),
+            name: resourceName(resolvedPath),
+        });
+        const edge = {
+            from,
+            to: id,
+            kind: "references",
+            via: resource.mentionedBy,
+            rawPath: resource.path,
+            resolvedPath,
+            unresolved: false,
+        };
+        await markUnresolved(resolvedPath, edge, warnings);
+        edges.push(edge);
+    }
+}
+function nearestSkillAncestor(skillRoot, skillByRoot) {
+    let current = dirname(skillRoot);
+    for (;;) {
+        const parent = skillByRoot.get(normalizePath(current));
+        if (parent) {
+            return parent;
+        }
+        const next = dirname(current);
+        if (next === current) {
+            return null;
+        }
+        current = next;
+    }
+}
+function referencedSkill(resolvedPath, parsedSkills) {
+    const normalized = normalizePath(resolvedPath);
+    const matches = parsedSkills
+        .filter((entry) => {
+        const root = normalizePath(entry.rootPath);
+        const skillFile = normalizePath(join(entry.rootPath, "SKILL.md"));
+        return normalized === root || normalized === skillFile || normalized.startsWith(`${root}/`);
+    })
+        .sort((left, right) => right.rootPath.length - left.rootPath.length);
+    return matches[0] ?? null;
+}
+function enumeratePaths(rootId, nodes, edges, maxDepth, maxPaths, warnings) {
+    const byFrom = new Map();
+    for (const edge of edges.filter((candidate) => !candidate.invalidCycle)) {
+        const list = byFrom.get(edge.from) ?? [];
+        list.push(edge);
+        byFrom.set(edge.from, list);
+    }
+    for (const list of byFrom.values()) {
+        list.sort((left, right) => (nodes.get(left.to)?.relativePath ?? left.to).localeCompare(nodes.get(right.to)?.relativePath ?? right.to));
+    }
+    const paths = [];
+    let truncated = false;
+    const pushPath = (path) => {
+        if (paths.length >= maxPaths) {
+            truncated = true;
+            return;
+        }
+        paths.push(path);
+    };
+    const visit = (id, trail, seen) => {
+        if (paths.length >= maxPaths) {
+            truncated = true;
+            return;
+        }
+        const next = byFrom.get(id) ?? [];
+        if (trail.length - 1 >= maxDepth) {
+            truncated ||= next.length > 0;
+            pushPath({ nodes: trail, leafKind: nodes.get(id)?.kind ?? "resource" });
+            return;
+        }
+        if (next.length === 0) {
+            pushPath({ nodes: trail, leafKind: nodes.get(id)?.kind ?? "resource" });
+            return;
+        }
+        for (const edge of next) {
+            if (paths.length >= maxPaths) {
+                truncated = true;
+                return;
+            }
+            if (seen.has(edge.to)) {
+                warnings.push(`cycle detected at ${nodes.get(edge.to)?.path ?? edge.to}`);
+                pushPath({ nodes: [...trail, edge.to], leafKind: nodes.get(edge.to)?.kind ?? "resource" });
+                continue;
+            }
+            visit(edge.to, [...trail, edge.to], new Set([...seen, edge.to]));
+        }
+    };
+    visit(rootId, [rootId], new Set([rootId]));
+    return { paths, truncated };
+}
+function markReferenceCycles(edges, nodes, warnings) {
+    const referenceEdges = edges.filter((edge) => edge.kind === "references_skill");
+    const byFrom = new Map();
+    for (const edge of referenceEdges) {
+        const list = byFrom.get(edge.from) ?? [];
+        list.push(edge);
+        byFrom.set(edge.from, list);
+    }
+    const warningKeys = new Set();
+    for (const edge of referenceEdges) {
+        if (!reaches(edge.to, edge.from, byFrom, new Set([edge.from]))) {
+            continue;
+        }
+        edge.invalidCycle = true;
+        const from = nodes.get(edge.from)?.relativePath ?? edge.from;
+        const to = nodes.get(edge.to)?.relativePath ?? edge.to;
+        const key = `${from}->${to}`;
+        if (!warningKeys.has(key)) {
+            warningKeys.add(key);
+            warnings.push(`invalid references_skill cycle: ${from} -> ${to}`);
+        }
+    }
+}
+function reaches(current, target, byFrom, seen) {
+    if (current === target) {
+        return true;
+    }
+    if (seen.has(current)) {
+        return false;
+    }
+    seen.add(current);
+    return (byFrom.get(current) ?? []).some((edge) => reaches(edge.to, target, byFrom, seen));
+}
+function nodeMap(graph) {
+    return new Map(graph.nodes.map((node) => [node.id, node]));
+}
+function activeEdges(graph) {
+    return graph.edges.filter((edge) => !edge.invalidCycle);
+}
+function neighbor(nodes, edge, direction) {
+    const node = nodes.get(direction === "outgoing" ? edge.to : edge.from);
+    return node ? { node, edge, direction } : null;
+}
+function compareNeighbors(left, right) {
+    const direction = left.direction.localeCompare(right.direction);
+    if (direction !== 0) {
+        return direction;
+    }
+    const kind = left.edge.kind.localeCompare(right.edge.kind);
+    if (kind !== 0) {
+        return kind;
+    }
+    return left.node.relativePath.localeCompare(right.node.relativePath);
+}
+function skillNode(entry) {
+    return {
+        id: skillId(entry.rootPath),
+        kind: "skill",
+        path: entry.rootPath,
+        relativePath: entry.relativePath,
+        depth: entry.depth,
+        name: entry.skill.name,
+    };
+}
+function skillId(path) {
+    return sha256(path);
+}
+function normalizeMaxDepth(value) {
+    // Guard against NaN/Infinity from CLI parsing so depth truncation stays effective.
+    if (value === undefined || !Number.isFinite(value)) {
+        return DEFAULT_MAX_DEPTH;
+    }
+    return Math.max(1, Math.floor(value));
+}
+function normalizeMaxPaths(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return DEFAULT_MAX_PATHS;
+    }
+    return Math.max(1, Math.floor(value));
+}
+function resolveLocalResource(skillRoot, resource) {
+    return resource.isAbsolute ? normalize(resource.path) : resolve(skillRoot, resource.path);
+}
+async function markUnresolved(path, edge, warnings) {
+    try {
+        await access(path);
+    }
+    catch {
+        edge.unresolved = true;
+        warnings.push(`${path}: referenced path does not exist`);
+    }
+}
+function relativePath(root, path) {
+    const rel = relative(root, path).replace(/\\/g, "/");
+    return rel || ".";
+}
+function pathDepth(path) {
+    if (path === ".") {
+        return 0;
+    }
+    return path.split("/").filter(Boolean).length;
+}
+function resourceName(path) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(path)) {
+        return path;
+    }
+    return path.split(/[\\/]+/).filter(Boolean).at(-1) ?? path;
+}
+function normalizePath(path) {
+    return normalize(path).replace(/\\/g, "/");
+}
+function compareNodes(left, right) {
+    const path = left.relativePath.localeCompare(right.relativePath);
+    if (path !== 0) {
+        return path;
+    }
+    return left.kind.localeCompare(right.kind);
+}
+function finalizeEdges(edges, nodes) {
+    return edges
+        .map((edge) => ({
+        ...edge,
+        fromRelativePath: nodes.get(edge.from)?.relativePath,
+        toRelativePath: nodes.get(edge.to)?.relativePath,
+    }))
+        .sort((left, right) => {
+        const from = (left.fromRelativePath ?? left.from).localeCompare(right.fromRelativePath ?? right.from);
+        if (from !== 0) {
+            return from;
+        }
+        return (left.toRelativePath ?? left.to).localeCompare(right.toRelativePath ?? right.to);
+    });
+}
+//# sourceMappingURL=skill-graph.js.map