kibi-cli 0.14.0 → 0.17.0

package/dist/public/schemas/entity.js

@@ -18,6 +18,15 @@
 // Typed fact field enums per proposal
 import { SYMBOL_ROLES } from "../symbol-granularity.js";
 const factConditionals = JSON.parse(`[
+  {
+    "if": {
+      "anyOf": [
+        { "required": ["claim_key"] },
+        { "required": ["claim_text"] }
+      ]
+    },
+    "then": { "required": ["claim_key", "claim_text"] }
+  },
   {
     "if": {
       "properties": {
@@ -50,6 +59,30 @@ const factConditionals = JSON.parse(`[
       }
     }
   },
+  {
+    "if": {
+      "properties": {
+        "type": { "const": "fact" },
+        "fact_kind": { "const": "rule_schema" }
+      },
+      "required": ["type", "fact_kind"]
+    },
+    "then": {
+      "required": ["rule_name", "argument_names", "argument_types"]
+    }
+  },
+  {
+    "if": {
+      "properties": {
+        "type": { "const": "fact" },
+        "fact_kind": { "const": "rule" }
+      },
+      "required": ["type", "fact_kind"]
+    },
+    "then": {
+      "required": ["rule_ir", "rule_hash", "rule_schema_id", "rule_name", "semantic_key"]
+    }
+  },
   {
     "if": {
       "properties": {
@@ -65,10 +98,205 @@ const factConditionals = JSON.parse(`[
     }
   }
 ]`);
+// The persisted rule payload is still data, but its shape is constrained at
+// the JSON boundary as well as by validateLogicIr.  Keeping this vocabulary
+// closed prevents a raw_goal/raw Prolog field from entering an upsert payload.
+const logicTermSchema = {
+    oneOf: [
+        {
+            type: "object",
+            required: ["kind", "name", "type"],
+            properties: {
+                kind: { const: "var" },
+                name: { type: "string", pattern: "^[A-Z][A-Za-z0-9_]*$" },
+                type: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value"],
+            properties: {
+                kind: { const: "const" },
+                value: { type: "string", minLength: 1 },
+                type: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value"],
+            properties: {
+                kind: { const: "number" },
+                value: { type: "number" },
+                unit: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value", "unit"],
+            properties: {
+                kind: { const: "duration" },
+                value: { type: "number", minimum: 0 },
+                unit: { type: "string", enum: ["ms", "s", "m", "h", "d", "w"] },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value"],
+            properties: {
+                kind: { const: "timestamp" },
+                value: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "start", "end"],
+            properties: {
+                kind: { const: "interval" },
+                start: { type: "string" },
+                end: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    ],
+};
+const logicAtomSchema = {
+    type: "object",
+    required: ["kind", "name", "args"],
+    properties: {
+        kind: { const: "atom" },
+        namespace: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+        name: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+        args: {
+            type: "array",
+            maxItems: 8,
+            items: { $ref: "#/$defs/logicTerm" },
+        },
+        polarity: { enum: ["positive", "negative"] },
+        closedWorld: { type: "boolean" },
+    },
+    additionalProperties: false,
+};
+const logicExpressionSchema = {
+    oneOf: [
+        { $ref: "#/$defs/logicAtom" },
+        {
+            type: "object",
+            required: ["kind", "items"],
+            properties: {
+                kind: { enum: ["all", "any"] },
+                items: {
+                    type: "array",
+                    minItems: 1,
+                    maxItems: 32,
+                    items: { $ref: "#/$defs/logicExpression" },
+                },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "item"],
+            properties: {
+                kind: { const: "not" },
+                item: { $ref: "#/$defs/logicAtom" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "operator", "left", "right"],
+            properties: {
+                kind: { const: "compare" },
+                operator: { enum: ["eq", "neq", "lt", "lte", "gt", "gte"] },
+                left: { $ref: "#/$defs/logicTerm" },
+                right: { $ref: "#/$defs/logicTerm" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "atom", "operator", "value"],
+            properties: {
+                kind: { const: "count" },
+                atom: { $ref: "#/$defs/logicAtom" },
+                operator: { enum: ["eq", "neq", "lt", "lte", "gt", "gte"] },
+                value: { type: "integer", minimum: 0 },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "relation", "left", "right"],
+            properties: {
+                kind: { const: "temporal" },
+                relation: {
+                    enum: ["before", "after", "during", "overlaps", "starts", "finishes"],
+                },
+                left: { $ref: "#/$defs/logicTerm" },
+                right: { $ref: "#/$defs/logicTerm" },
+            },
+            additionalProperties: false,
+        },
+    ],
+};
+const logicRuleSchema = {
+    type: "object",
+    required: ["version", "kind", "modality"],
+    properties: {
+        version: { const: "kibi.logic.v1" },
+        kind: { enum: ["atom", "rule", "constraint"] },
+        modality: { enum: ["assert", "deny", "oblige", "permit", "forbid"] },
+        head: { $ref: "#/$defs/logicAtom" },
+        body: { $ref: "#/$defs/logicExpression" },
+        variables: {
+            type: "array",
+            maxItems: 32,
+            items: {
+                type: "object",
+                required: ["name", "type"],
+                properties: {
+                    name: { type: "string", pattern: "^[A-Z][A-Za-z0-9_]*$" },
+                    type: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+                    quantifier: { enum: ["forall", "exists"] },
+                },
+                additionalProperties: false,
+            },
+        },
+        exceptions: {
+            type: "array",
+            maxItems: 16,
+            items: { $ref: "#/$defs/logicExpression" },
+        },
+        scope: {
+            type: "object",
+            properties: {
+                authority: { type: "string" },
+                name: { type: "string" },
+                tags: { type: "array", items: { type: "string" } },
+            },
+            additionalProperties: false,
+        },
+        validFrom: { type: "string" },
+        validTo: { type: "string" },
+        ruleSchemaId: { type: "string", minLength: 1 },
+    },
+    additionalProperties: false,
+};
 const entitySchema = {
     $id: "entity.schema.json",
     title: "Entity",
     type: "object",
+    $defs: {
+        logicTerm: logicTermSchema,
+        logicAtom: logicAtomSchema,
+        logicExpression: logicExpressionSchema,
+        logicRule: logicRuleSchema,
+    },
     properties: {
         id: { type: "string" },
         title: { type: "string" },
@@ -105,6 +333,59 @@ const entitySchema = {
         severity: { type: "string" },
         links: { type: "array", items: { type: "string" } },
         text_ref: { type: "string" },
+        logic_claims: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+            items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+        },
+        semantic_inventory: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["claim_key", "claim_text", "role", "status", "span"],
+                properties: {
+                    claim_key: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+                    claim_text: { type: "string", minLength: 1 },
+                    role: {
+                        type: "string",
+                        enum: [
+                            "normative",
+                            "definition",
+                            "descriptive",
+                            "condition",
+                            "exception",
+                            "rationale",
+                            "example",
+                            "subjective",
+                        ],
+                    },
+                    status: {
+                        type: "string",
+                        enum: [
+                            "modeled",
+                            "ambiguous",
+                            "ontology_gap",
+                            "nonlogical",
+                            "missing",
+                        ],
+                    },
+                    span: {
+                        type: "object",
+                        required: ["start", "end"],
+                        properties: {
+                            start: { type: "integer", minimum: 0 },
+                            end: { type: "integer", minimum: 0 },
+                        },
+                        additionalProperties: false,
+                    },
+                    semantic_key: { type: "string" },
+                    payload_hash: { type: "string" },
+                    reason: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
         sourceFile: { type: "string" },
         granularity_reason: {
             type: "string",
@@ -150,6 +431,8 @@ const entitySchema = {
                 "meta",
                 "predicate_schema",
                 "predicate",
+                "rule_schema",
+                "rule",
             ],
         },
         subject_key: { type: "string" },
@@ -170,6 +453,8 @@ const entitySchema = {
         valid_from: { type: "string" },
         valid_to: { type: "string" },
         canonical_key: { type: "string" },
+        claim_key: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+        claim_text: { type: "string" },
         predicate_name: { type: "string" },
         predicate_namespace: { type: "string" },
         predicate_arity: { type: "integer", minimum: 1 },
@@ -179,6 +464,13 @@ const entitySchema = {
         aliases: { type: "array", items: { type: "string" } },
         examples: { type: "array", items: { type: "string" } },
         predicate_args: { type: "array", items: { type: "string" } },
+        rule_ir: { $ref: "#/$defs/logicRule" },
+        rule_hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        rule_schema_id: { type: "string", minLength: 1 },
+        rule_name: { type: "string", minLength: 1 },
+        semantic_key: { type: "string", pattern: "^SEM-[A-F0-9]{24}$" },
+        claim_span_start: { type: "integer", minimum: 0 },
+        claim_span_end: { type: "integer", minimum: 0 },
     },
     required: [
         "id",
@@ -190,6 +482,14 @@ const entitySchema = {
         "type",
     ],
     allOf: [
+        {
+            if: {
+                properties: { type: { const: "req" } },
+            },
+            else: {
+                not: { required: ["logic_claims"] },
+            },
+        },
         // Forbid fact-only fields on non-fact entities
         {
             if: {
@@ -216,6 +516,8 @@ const entitySchema = {
                         { required: ["valid_from"] },
                         { required: ["valid_to"] },
                         { required: ["canonical_key"] },
+                        { required: ["claim_key"] },
+                        { required: ["claim_text"] },
                         { required: ["predicate_name"] },
                         { required: ["predicate_namespace"] },
                         { required: ["predicate_arity"] },
@@ -225,6 +527,13 @@ const entitySchema = {
                         { required: ["aliases"] },
                         { required: ["examples"] },
                         { required: ["predicate_args"] },
+                        { required: ["rule_ir"] },
+                        { required: ["rule_hash"] },
+                        { required: ["rule_schema_id"] },
+                        { required: ["rule_name"] },
+                        { required: ["semantic_key"] },
+                        { required: ["claim_span_start"] },
+                        { required: ["claim_span_end"] },
                     ],
                 },
             },
@@ -242,6 +551,14 @@ const entitySchema = {
                 },
             },
         },
+        {
+            if: {
+                properties: { type: { const: "req" } },
+            },
+            else: {
+                not: { required: ["semantic_inventory"] },
+            },
+        },
         ...factConditionals,
     ],
     additionalProperties: false,

package/dist/public/schemas/relationship.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/relationship.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/relationship.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/public/schemas/relationship.js

@@ -34,6 +34,7 @@ const relationshipSchema = {
                 "constrains",
                 "requires_property",
                 "requires_predicate",
+                "requires_rule",
                 "guards",
                 "publishes",
                 "consumes",

package/dist/public/skill-system/errors.d.ts

@@ -0,0 +1,19 @@
+export declare class SkillNotFoundError extends Error {
+    constructor(id: string);
+}
+export declare class SkillResourceNotFoundError extends Error {
+    constructor(id: string, resourcePath: string);
+}
+export declare class SkillResourceOutOfBoundsError extends Error {
+    constructor(id: string, resourcePath: string);
+}
+export declare class SkillValidationError extends Error {
+    readonly field: string;
+    constructor(field: string, message: string);
+}
+export declare class SkillOversizeError extends Error {
+    readonly maxBytes: number;
+    readonly actualBytes: number;
+    constructor(pathLike: string, maxBytes: number, actualBytes: number);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/public/skill-system/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/public/skill-system/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,EAAE,EAAE,MAAM;CAIvB;AACD,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CAI7C;AACD,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CAI7C;AACD,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBACX,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK3C;AACD,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBACjB,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAQpE"}

package/dist/public/skill-system/errors.js

@@ -0,0 +1,36 @@
+export class SkillNotFoundError extends Error {
+    constructor(id) {
+        super(`Skill not found: ${id}`);
+        this.name = "SkillNotFoundError";
+    }
+}
+export class SkillResourceNotFoundError extends Error {
+    constructor(id, resourcePath) {
+        super(`Skill resource not found: ${id}/${resourcePath}`);
+        this.name = "SkillResourceNotFoundError";
+    }
+}
+export class SkillResourceOutOfBoundsError extends Error {
+    constructor(id, resourcePath) {
+        super(`Skill resource escapes bundle root: ${id}/${resourcePath}`);
+        this.name = "SkillResourceOutOfBoundsError";
+    }
+}
+export class SkillValidationError extends Error {
+    field;
+    constructor(field, message) {
+        super(message);
+        this.name = "SkillValidationError";
+        this.field = field;
+    }
+}
+export class SkillOversizeError extends Error {
+    maxBytes;
+    actualBytes;
+    constructor(pathLike, maxBytes, actualBytes) {
+        super(`Skill file exceeds ${maxBytes} bytes: ${pathLike} (${actualBytes} bytes)`);
+        this.name = "SkillOversizeError";
+        this.maxBytes = maxBytes;
+        this.actualBytes = actualBytes;
+    }
+}

package/dist/public/skill-system/loader.d.ts

@@ -0,0 +1,9 @@
+import type { SkillBundle, SkillManifest } from "./types.js";
+export declare function setBundledSkillsDir(dir: string): void;
+export declare function resetBundledSkillsDir(): void;
+export declare function listBundledSkills(): SkillManifest[];
+export declare function loadBundledSkill(id: string): SkillBundle;
+export declare function loadBundledSkillFrom(skillsDir: string, id: string): SkillBundle;
+export declare function readBundledSkillResource(id: string, resourcePath: string): string;
+export declare function readBundledSkillResourceFrom(skillsDir: string, id: string, resourcePath: string): string;
+//# sourceMappingURL=loader.d.ts.map

package/dist/public/skill-system/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/public/skill-system/loader.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAW7D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAErD;AACD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AACD,wBAAgB,iBAAiB,IAAI,aAAa,EAAE,CAEnD;AACD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,CAExD;AAGD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,GACT,WAAW,CAIb;AACD,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,MAAM,GACnB,MAAM,CAER;AAGD,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,MAAM,GACnB,MAAM,CAER"}

package/dist/public/skill-system/loader.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SkillNotFoundError, SkillResourceNotFoundError, SkillResourceOutOfBoundsError, } from "./errors.js";
+import { SKILL_FILE_NAME, isPathOutOfBounds, isWithinRoot, normalizeResourcePath, } from "./paths.js";
+import { RESOURCE_MAX_BYTES, assertMaxBytes, parseSkillBundle, } from "./validation.js";
+const defaultBundledSkillsDir = resolve(dirname(fileURLToPath(import.meta.url)), "../skills");
+let bundledSkillsDir = defaultBundledSkillsDir;
+export function setBundledSkillsDir(dir) {
+    bundledSkillsDir = dir;
+}
+export function resetBundledSkillsDir() {
+    bundledSkillsDir = defaultBundledSkillsDir;
+}
+export function listBundledSkills() {
+    return listFrom(bundledSkillsDir);
+}
+export function loadBundledSkill(id) {
+    return loadBundledSkillFrom(bundledSkillsDir, id);
+}
+// implements REQ-reusable-skill-subsystem
+// covered_by TEST-skill-cli-load-validate
+export function loadBundledSkillFrom(skillsDir, id) {
+    const root = findRoot(resolve(skillsDir), id);
+    if (!root)
+        throw new SkillNotFoundError(id);
+    return parseSkillBundle(root);
+}
+export function readBundledSkillResource(id, resourcePath) {
+    return readBundle(loadBundledSkill(id), id, resourcePath);
+}
+// implements REQ-reusable-skill-subsystem
+// covered_by TEST-skill-cli-load-validate
+export function readBundledSkillResourceFrom(skillsDir, id, resourcePath) {
+    return readBundle(loadBundledSkillFrom(skillsDir, id), id, resourcePath);
+}
+function listFrom(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(dir, entry.name))
+        .filter((root) => existsSync(join(root, SKILL_FILE_NAME)))
+        .map((root) => parseSkillBundle(root).manifest)
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+function findRoot(dir, id) {
+    return listRoots(dir).find((root) => parseSkillBundle(root).manifest.id === id);
+}
+function listRoots(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(dir, entry.name))
+        .filter((root) => existsSync(join(root, SKILL_FILE_NAME)));
+}
+function readBundle(bundle, id, resourcePath) {
+    const resource = normalizeResourcePath(resourcePath);
+    if (!resource || isPathOutOfBounds(resourcePath))
+        throw new SkillResourceOutOfBoundsError(id, resourcePath);
+    if (!(bundle.manifest.resources ?? []).some((declared) => normalizeResourcePath(declared) === resource))
+        throw new SkillResourceNotFoundError(id, resourcePath);
+    const candidate = resolve(bundle.rootDir, resource);
+    try {
+        if (!isWithinRoot(realpathSync(bundle.rootDir), realpathSync(candidate)))
+            throw new SkillResourceOutOfBoundsError(id, resourcePath);
+    }
+    catch (error) {
+        if (error instanceof SkillResourceOutOfBoundsError)
+            throw error;
+        throw new SkillResourceNotFoundError(id, resourcePath);
+    }
+    assertMaxBytes(candidate, RESOURCE_MAX_BYTES);
+    return readFileSync(candidate, "utf8");
+}

package/dist/public/skill-system/paths.d.ts

@@ -0,0 +1,6 @@
+export declare const SKILL_FILE_NAME = "SKILL.md";
+export declare function normalizeResourcePath(pathLike: string): string;
+export declare function isPathOutOfBounds(pathLike: string): boolean;
+export declare function isWithinRoot(rootDir: string, candidatePath: string): boolean;
+export declare function resolveSkillFilePath(pathLike: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/public/skill-system/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/public/skill-system/paths.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,aAAa,CAAC;AAC1C,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9D;AACD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQ3D;AACD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAG5E;AACD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAO7D"}

package/dist/public/skill-system/paths.js

@@ -0,0 +1,25 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, join, normalize, relative, resolve } from "node:path";
+export const SKILL_FILE_NAME = "SKILL.md";
+export function normalizeResourcePath(pathLike) {
+    return normalize(pathLike).replaceAll("\\", "/");
+}
+export function isPathOutOfBounds(pathLike) {
+    const normalized = normalizeResourcePath(pathLike);
+    return (isAbsolute(pathLike) ||
+        normalized === ".." ||
+        normalized.startsWith("../") ||
+        normalized.includes("/../"));
+}
+export function isWithinRoot(rootDir, candidatePath) {
+    const rel = relative(rootDir, candidatePath);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+export function resolveSkillFilePath(pathLike) {
+    const resolved = resolve(pathLike);
+    if (existsSync(resolved) && statSync(resolved).isDirectory())
+        return join(resolved, SKILL_FILE_NAME);
+    return resolved.endsWith(SKILL_FILE_NAME)
+        ? resolved
+        : join(resolved, SKILL_FILE_NAME);
+}

package/dist/public/skill-system/types.d.ts

@@ -0,0 +1,15 @@
+export interface SkillManifest {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    kibiCompatibility: string;
+    tags?: string[];
+    resources?: string[];
+}
+export interface SkillBundle {
+    manifest: SkillManifest;
+    body: string;
+    rootDir: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/public/skill-system/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/public/skill-system/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AACD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/public/skill-system/types.js

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

package/dist/public/skill-system/validation.d.ts

@@ -0,0 +1,10 @@
+import { SkillValidationError } from "./errors.js";
+import type { SkillBundle } from "./types.js";
+export declare const RESOURCE_MAX_BYTES: number;
+export declare function assertMaxBytes(pathLike: string, maxBytes: number): void;
+export declare function parseSkillBundle(rootDir: string): SkillBundle;
+export declare function validateSkillBundle(pathLike: string): {
+    valid: boolean;
+    errors: SkillValidationError[];
+};
+//# sourceMappingURL=validation.d.ts.map

package/dist/public/skill-system/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/public/skill-system/validation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAQvE,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,YAAY,CAAC;AAE7D,eAAO,MAAM,kBAAkB,QAAa,CAAC;AAC7C,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAGvE;AACD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAW7D;AACD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACrD,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,oBAAoB,EAAE,CAAC;CAChC,CAeA"}