@a5c-ai/agent-platform 5.0.1-staging.016f0b0e8119

package/dist/session/write.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Session state file writing utilities.
+ * Provides atomic writes for session state files.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeSessionState = serializeSessionState;
+exports.createSessionFileContent = createSessionFileContent;
+exports.writeSessionFile = writeSessionFile;
+exports.updateSessionState = updateSessionState;
+exports.addRunToSession = addRunToSession;
+exports.getSessionRuns = getSessionRuns;
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.isoToEpochSeconds = isoToEpochSeconds;
+exports.updateIterationTimes = updateIterationTimes;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+/**
+ * Serialize session state to YAML frontmatter format.
+ */
+function serializeSessionState(state) {
+    const lines = [];
+    lines.push(`active: ${state.active}`);
+    lines.push(`iteration: ${state.iteration}`);
+    lines.push(`max_iterations: ${state.maxIterations}`);
+    lines.push(`run_id: "${state.runId}"`);
+    lines.push(`run_ids: ${state.runIds.join(',')}`);
+    lines.push(`started_at: "${state.startedAt}"`);
+    lines.push(`last_iteration_at: "${state.lastIterationAt}"`);
+    lines.push(`iteration_times: ${state.iterationTimes.join(',')}`);
+    for (const [key, value] of Object.entries(state.metadata ?? {})) {
+        lines.push(`metadata_${key}: "${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Create full session file content with YAML frontmatter and prompt.
+ */
+function createSessionFileContent(state, prompt) {
+    const frontmatter = serializeSessionState(state);
+    return `---\n${frontmatter}\n---\n\n${prompt}\n`;
+}
+/**
+ * Write session state file atomically.
+ * Uses temp file + rename pattern to ensure atomic writes.
+ */
+async function writeSessionFile(filePath, state, prompt) {
+    const content = createSessionFileContent(state, prompt);
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    try {
+        // Ensure directory exists
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        // Write to temp file
+        await node_fs_1.promises.writeFile(tempPath, content, 'utf8');
+        // Atomic rename
+        await node_fs_1.promises.rename(tempPath, filePath);
+    }
+    catch (error) {
+        // Clean up temp file on error
+        try {
+            await node_fs_1.promises.unlink(tempPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        const err = error;
+        throw new types_1.SessionError(`Failed to write session state file: ${err.message}`, types_1.SessionErrorCode.FS_ERROR, { filePath, originalError: err.message });
+    }
+}
+/**
+ * Update specific fields in an existing session state file.
+ * Reads, modifies, and atomically writes the file.
+ */
+async function updateSessionState(filePath, updates, existingContent) {
+    let state;
+    let prompt;
+    if (existingContent) {
+        state = existingContent.state;
+        prompt = existingContent.prompt;
+    }
+    else {
+        // Read existing file
+        const { readSessionFile } = await Promise.resolve().then(() => __importStar(require('./parse')));
+        const file = await readSessionFile(filePath);
+        state = file.state;
+        prompt = file.prompt;
+    }
+    // Apply updates
+    const updatedState = {
+        ...state,
+        ...updates,
+    };
+    // Write updated file
+    await writeSessionFile(filePath, updatedState, prompt);
+    return updatedState;
+}
+/**
+ * Bind a new run to the session, retiring the previous active run to history.
+ *
+ * Invariant: only one run is active at a time (`runId`).
+ * The previous `runId` (if any) is pushed into `runIds` as audit history.
+ * Idempotent: re-binding the same runId is a no-op.
+ *
+ * Throws if the caller tries to bind a new run while `runId` is still set
+ * and `retirePrevious` is not explicitly true — this forces callers to
+ * acknowledge that the prior run is done.
+ */
+function addRunToSession(state, runId, options) {
+    // Idempotent: already bound to this run
+    if (state.runId === runId)
+        return state;
+    // Guard: refuse to silently overwrite an active run
+    if (state.runId && !options?.retirePrevious) {
+        throw new types_1.SessionError(`Session already bound to run ${state.runId}. ` +
+            `Pass { retirePrevious: true } to retire it and bind ${runId}.`, types_1.SessionErrorCode.RUN_ALREADY_ASSOCIATED, { currentRunId: state.runId, requestedRunId: runId });
+    }
+    // Retire the old runId into history (if not already there)
+    const runIds = [...state.runIds];
+    if (state.runId && !runIds.includes(state.runId)) {
+        runIds.push(state.runId);
+    }
+    // Add the new one to the audit trail too
+    if (!runIds.includes(runId)) {
+        runIds.push(runId);
+    }
+    return { ...state, runId, runIds };
+}
+/**
+ * Get the historical audit trail of all run IDs for this session (GAP-SESSION-001).
+ * Falls back to [runId] when runIds is empty for backward compatibility
+ * with sessions created before the runIds field existed.
+ */
+function getSessionRuns(state) {
+    if (state.runIds.length > 0)
+        return state.runIds;
+    return state.runId ? [state.runId] : [];
+}
+/**
+ * Get current ISO timestamp.
+ */
+function getCurrentTimestamp() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+/**
+ * Convert ISO timestamp to epoch seconds.
+ * Returns null if conversion fails.
+ */
+function isoToEpochSeconds(isoTimestamp) {
+    if (!isoTimestamp)
+        return null;
+    try {
+        const date = new Date(isoTimestamp);
+        if (Number.isNaN(date.getTime()))
+            return null;
+        return Math.floor(date.getTime() / 1000);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate iteration duration and update times array.
+ * Keeps only the last 10 durations for diagnostics.
+ */
+function updateIterationTimes(existingTimes, lastIterationAt, currentTime) {
+    const lastEpoch = isoToEpochSeconds(lastIterationAt);
+    const currentEpoch = isoToEpochSeconds(currentTime);
+    if (lastEpoch === null || currentEpoch === null) {
+        return existingTimes;
+    }
+    const duration = currentEpoch - lastEpoch;
+    if (duration <= 0) {
+        return existingTimes;
+    }
+    const newTimes = [...existingTimes, duration];
+    // Keep only last 10
+    return newTimes.slice(-10);
+}

package/dist/skills/chain.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SkillChainBuilder — assembles an ordered chain of skill invocations with
+ * dependency tracking and topological validation.
+ */
+import type { SkillChain, SkillChainStep } from './types';
+import type { SkillRouter } from './router';
+/**
+ * Build a SkillChain from individual steps, producing a topologically sorted
+ * execution order that respects `dependsOn` declarations.
+ */
+export declare class SkillChainBuilder {
+    private readonly steps;
+    private description;
+    /** Append a step to the chain. */
+    addStep(step: SkillChainStep): this;
+    /** Set the chain's human-readable description. */
+    setDescription(description: string): this;
+    /**
+     * Build the chain, topologically sorting steps so that every step appears
+     * after all of its `dependsOn` prerequisites.
+     *
+     * Throws if the dependency graph contains a cycle.
+     */
+    build(): SkillChain;
+    /**
+     * Validate that every skill referenced in the chain is registered in the
+     * given router. Returns an array of missing skill names (empty = valid).
+     */
+    validate(router: SkillRouter): string[];
+}
+//# sourceMappingURL=chain.d.ts.map

package/dist/skills/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../src/skills/chain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,WAAW,CAAM;IAEzB,kCAAkC;IAClC,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAKnC,kDAAkD;IAClD,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKzC;;;;;OAKG;IACH,KAAK,IAAI,UAAU;IAQnB;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE;CASxC"}

package/dist/skills/chain.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * SkillChainBuilder — assembles an ordered chain of skill invocations with
+ * dependency tracking and topological validation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillChainBuilder = void 0;
+/**
+ * Build a SkillChain from individual steps, producing a topologically sorted
+ * execution order that respects `dependsOn` declarations.
+ */
+class SkillChainBuilder {
+    steps = [];
+    description = '';
+    /** Append a step to the chain. */
+    addStep(step) {
+        this.steps.push(step);
+        return this;
+    }
+    /** Set the chain's human-readable description. */
+    setDescription(description) {
+        this.description = description;
+        return this;
+    }
+    /**
+     * Build the chain, topologically sorting steps so that every step appears
+     * after all of its `dependsOn` prerequisites.
+     *
+     * Throws if the dependency graph contains a cycle.
+     */
+    build() {
+        const sorted = topologicalSort(this.steps);
+        return {
+            steps: sorted,
+            description: this.description,
+        };
+    }
+    /**
+     * Validate that every skill referenced in the chain is registered in the
+     * given router. Returns an array of missing skill names (empty = valid).
+     */
+    validate(router) {
+        const missing = [];
+        for (const step of this.steps) {
+            if (!router.get(step.skillName)) {
+                missing.push(step.skillName);
+            }
+        }
+        return missing;
+    }
+}
+exports.SkillChainBuilder = SkillChainBuilder;
+// ---- topological sort (Kahn's algorithm) ----
+function topologicalSort(steps) {
+    const byName = new Map();
+    for (const step of steps) {
+        byName.set(step.skillName, step);
+    }
+    // Build adjacency and in-degree structures
+    const inDegree = new Map();
+    const dependents = new Map(); // prerequisite -> list of dependents
+    for (const step of steps) {
+        if (!inDegree.has(step.skillName)) {
+            inDegree.set(step.skillName, 0);
+        }
+        if (step.dependsOn) {
+            for (const dep of step.dependsOn) {
+                inDegree.set(step.skillName, (inDegree.get(step.skillName) ?? 0) + 1);
+                const list = dependents.get(dep) ?? [];
+                list.push(step.skillName);
+                dependents.set(dep, list);
+                // Ensure dep has an in-degree entry even if it wasn't added as a step
+                if (!inDegree.has(dep)) {
+                    inDegree.set(dep, 0);
+                }
+            }
+        }
+    }
+    // Collect nodes with in-degree 0
+    const queue = [];
+    for (const [name, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(name);
+        }
+    }
+    // Stable ordering: sort the initial queue alphabetically
+    queue.sort();
+    const sorted = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const step = byName.get(current);
+        if (step) {
+            sorted.push(step);
+        }
+        for (const dependent of dependents.get(current) ?? []) {
+            const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) {
+                queue.push(dependent);
+                queue.sort(); // keep stable ordering
+            }
+        }
+    }
+    // If we didn't visit every step, there's a cycle
+    if (sorted.length < steps.length) {
+        const visited = new Set(sorted.map((s) => s.skillName));
+        const cycleMembers = steps
+            .filter((s) => !visited.has(s.skillName))
+            .map((s) => s.skillName);
+        throw new Error(`Dependency cycle detected among skills: ${cycleMembers.join(', ')}`);
+    }
+    return sorted;
+}

package/dist/skills/discovery.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SkillDiscoveryService — scans directories for SKILL.md files, parses
+ * frontmatter, and converts them to SkillDescriptor instances for the router.
+ */
+import type { SkillDescriptor } from './types';
+/** Raw parsed representation from a SKILL.md file before normalization. */
+export interface RawSkillEntry {
+    name: string;
+    description: string;
+    capabilities: string[];
+    triggers: string[];
+    domain: string | undefined;
+    filePath: string;
+    frontmatter: Record<string, unknown>;
+}
+export declare class SkillDiscoveryService {
+    /**
+     * Parse a single SKILL.md file into a RawSkillEntry.
+     */
+    parseSkillFile(filePath: string): RawSkillEntry;
+    /**
+     * Convert a RawSkillEntry (or any raw-shaped object) to a SkillDescriptor.
+     */
+    toDescriptor(raw: RawSkillEntry, source?: SkillDescriptor['source']): SkillDescriptor;
+    /**
+     * Scan a single directory tree for SKILL.md files and return descriptors.
+     */
+    discoverLocal(dir: string): SkillDescriptor[];
+    /**
+     * Scan multiple plugin directories and return descriptors with source='plugin'.
+     */
+    discoverPlugins(dirs: string[]): SkillDescriptor[];
+}
+//# sourceMappingURL=discovery.d.ts.map

package/dist/skills/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/skills/discovery.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AA0HD,qBAAa,qBAAqB;IAChC;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa;IAgC/C;;OAEG;IACH,YAAY,CACV,GAAG,EAAE,aAAa,EAClB,MAAM,GAAE,eAAe,CAAC,QAAQ,CAAW,GAC1C,eAAe;IAYlB;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,EAAE;IAM7C;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE;CAWnD"}

package/dist/skills/discovery.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * SkillDiscoveryService — scans directories for SKILL.md files, parses
+ * frontmatter, and converts them to SkillDescriptor instances for the router.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillDiscoveryService = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// ---- frontmatter parsing ----
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    // Lightweight YAML-like parser for simple key: value pairs and arrays.
+    // Avoids pulling in a full YAML parser dependency.
+    const lines = (match[1] ?? '').split(/\r?\n/);
+    const fm = {};
+    let currentKey = '';
+    let currentArray = null;
+    for (const line of lines) {
+        const arrayItem = line.match(/^\s+-\s+(.*)/);
+        if (arrayItem && currentKey) {
+            if (!currentArray) {
+                currentArray = [];
+            }
+            currentArray.push(arrayItem[1].trim());
+            continue;
+        }
+        // Flush pending array
+        if (currentArray && currentKey) {
+            fm[currentKey] = currentArray;
+            currentArray = null;
+        }
+        const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+        if (kvMatch) {
+            currentKey = kvMatch[1];
+            const value = kvMatch[2].trim();
+            if (value.length > 0) {
+                // Inline array: [a, b, c]
+                if (value.startsWith('[') && value.endsWith(']')) {
+                    fm[currentKey] = value
+                        .slice(1, -1)
+                        .split(',')
+                        .map((s) => s.trim().replace(/^["']|["']$/g, ''))
+                        .filter((s) => s.length > 0);
+                }
+                else {
+                    fm[currentKey] = value.replace(/^["']|["']$/g, '');
+                }
+            }
+        }
+    }
+    // Flush trailing array
+    if (currentArray && currentKey) {
+        fm[currentKey] = currentArray;
+    }
+    return { frontmatter: fm, body: content.slice(match[0].length) };
+}
+function firstParagraph(body) {
+    const lines = body
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith('#') && !l.startsWith('```'));
+    return lines[0] ?? '';
+}
+function toStringArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === 'string' && v.length > 0);
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return [value];
+    }
+    return [];
+}
+// ---- filesystem helpers ----
+function isDir(p) {
+    try {
+        return node_fs_1.default.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function readFileUtf8(p) {
+    return node_fs_1.default.readFileSync(p, 'utf8');
+}
+function walkForSkillFiles(dir) {
+    const results = [];
+    const walk = (current) => {
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(current);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.startsWith('.'))
+                continue;
+            const full = node_path_1.default.join(current, entry);
+            if (isDir(full)) {
+                walk(full);
+            }
+            else if (entry === 'SKILL.md') {
+                results.push(full);
+            }
+        }
+    };
+    walk(dir);
+    return results.sort();
+}
+// ---- public API ----
+class SkillDiscoveryService {
+    /**
+     * Parse a single SKILL.md file into a RawSkillEntry.
+     */
+    parseSkillFile(filePath) {
+        const content = readFileUtf8(filePath);
+        const { frontmatter, body } = parseFrontmatter(content);
+        const name = typeof frontmatter.name === 'string' && frontmatter.name.length > 0
+            ? frontmatter.name
+            : node_path_1.default.basename(node_path_1.default.dirname(filePath));
+        const description = typeof frontmatter.description === 'string' && frontmatter.description.length > 0
+            ? frontmatter.description
+            : firstParagraph(body);
+        const capabilities = toStringArray(frontmatter.capabilities);
+        const triggers = toStringArray(frontmatter.triggers);
+        const domain = typeof frontmatter.domain === 'string' && frontmatter.domain.length > 0
+            ? frontmatter.domain
+            : undefined;
+        return {
+            name,
+            description,
+            capabilities,
+            triggers,
+            domain,
+            filePath,
+            frontmatter,
+        };
+    }
+    /**
+     * Convert a RawSkillEntry (or any raw-shaped object) to a SkillDescriptor.
+     */
+    toDescriptor(raw, source = 'local') {
+        return {
+            name: raw.name,
+            description: raw.description,
+            capabilities: raw.capabilities.length > 0 ? raw.capabilities : undefined,
+            source,
+            triggers: raw.triggers.length > 0 ? raw.triggers : undefined,
+            domain: raw.domain,
+            filePath: raw.filePath,
+        };
+    }
+    /**
+     * Scan a single directory tree for SKILL.md files and return descriptors.
+     */
+    discoverLocal(dir) {
+        if (!isDir(dir))
+            return [];
+        const files = walkForSkillFiles(dir);
+        return files.map((f) => this.toDescriptor(this.parseSkillFile(f), 'local'));
+    }
+    /**
+     * Scan multiple plugin directories and return descriptors with source='plugin'.
+     */
+    discoverPlugins(dirs) {
+        const results = [];
+        for (const dir of dirs) {
+            if (!isDir(dir))
+                continue;
+            const files = walkForSkillFiles(dir);
+            for (const f of files) {
+                results.push(this.toDescriptor(this.parseSkillFile(f), 'plugin'));
+            }
+        }
+        return results;
+    }
+}
+exports.SkillDiscoveryService = SkillDiscoveryService;

package/dist/skills/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Skill routing module for L6 Agent-Platform.
+ *
+ * Provides skill registration, criteria-based matching, filesystem discovery,
+ * and chain-of-skills orchestration.
+ */
+export type { SkillDescriptor, SkillMatchCriteria, SkillMatchResult, SkillChainStep, SkillChain, } from './types';
+export { SkillRouter } from './router';
+export { SkillDiscoveryService } from './discovery';
+export type { RawSkillEntry } from './discovery';
+export { SkillChainBuilder } from './chain';
+//# sourceMappingURL=index.d.ts.map

package/dist/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skills/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,UAAU,GACX,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/skills/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Skill routing module for L6 Agent-Platform.
+ *
+ * Provides skill registration, criteria-based matching, filesystem discovery,
+ * and chain-of-skills orchestration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillChainBuilder = exports.SkillDiscoveryService = exports.SkillRouter = void 0;
+// Router
+var router_1 = require("./router");
+Object.defineProperty(exports, "SkillRouter", { enumerable: true, get: function () { return router_1.SkillRouter; } });
+// Discovery
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "SkillDiscoveryService", { enumerable: true, get: function () { return discovery_1.SkillDiscoveryService; } });
+// Chain builder
+var chain_1 = require("./chain");
+Object.defineProperty(exports, "SkillChainBuilder", { enumerable: true, get: function () { return chain_1.SkillChainBuilder; } });

package/dist/skills/router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SkillRouter — registers skill descriptors and scores them against match criteria.
+ *
+ * Scoring strategy:
+ *   1. Keyword overlap between criteria text (taskType + context) and the skill's
+ *      description / capabilities / triggers.
+ *   2. Exact domain match bonus.
+ *   3. Trigger pattern match bonus.
+ *   4. Capability intersection bonus.
+ */
+import type { SkillDescriptor, SkillMatchCriteria, SkillMatchResult } from './types';
+export declare class SkillRouter {
+    private readonly skills;
+    /** Register a skill descriptor. Replaces any existing entry with the same name. */
+    register(descriptor: SkillDescriptor): void;
+    /** Remove a skill by name. Returns true if it existed. */
+    unregister(name: string): boolean;
+    /** Return the number of registered skills. */
+    get size(): number;
+    /** Iterate over all registered descriptors. */
+    descriptors(): IterableIterator<SkillDescriptor>;
+    /** Retrieve a registered descriptor by name. */
+    get(name: string): SkillDescriptor | undefined;
+    /**
+     * Score every registered skill against the given criteria and return
+     * results sorted by descending score. Skills that score 0 are excluded.
+     */
+    match(criteria: SkillMatchCriteria): SkillMatchResult[];
+    /**
+     * Return the single best matching skill, or undefined when nothing matches.
+     */
+    select(criteria: SkillMatchCriteria): SkillMatchResult | undefined;
+    private scoreSkill;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/skills/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/skills/router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AA2BjB,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsC;IAE7D,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAI3C,0DAA0D;IAC1D,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,8CAA8C;IAC9C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+CAA+C;IAC/C,WAAW,IAAI,gBAAgB,CAAC,eAAe,CAAC;IAIhD,gDAAgD;IAChD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI9C;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,kBAAkB,GAAG,gBAAgB,EAAE;IAavD;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,SAAS;IAOlE,OAAO,CAAC,UAAU;CAwEnB"}