@shrkcrft/knowledge 0.1.0-alpha.2

package/dist/load/markdown-knowledge-loader.js

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, extname } from 'node:path';
+import { KnowledgeType } from "../model/knowledge-type.js";
+import { KnowledgePriority } from "../model/knowledge-priority.js";
+import { normalizeKnowledgeId, toKebabCase } from '@shrkcrft/core';
+const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+function parseFrontmatter(text) {
+    const match = FRONTMATTER_RE.exec(text);
+    if (!match)
+        return { meta: {}, body: text };
+    const block = match[1] ?? '';
+    const body = text.slice(match[0].length);
+    const meta = {};
+    for (const line of block.split('\n')) {
+        const idx = line.indexOf(':');
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        let value = line.slice(idx + 1).trim();
+        if (value.startsWith('[') && value.endsWith(']')) {
+            value = value
+                .slice(1, -1)
+                .split(',')
+                .map((v) => v.replace(/^["']|["']$/g, '').trim())
+                .filter(Boolean);
+        }
+        else if (value.startsWith('"') || value.startsWith("'")) {
+            value = value.replace(/^["']|["']$/g, '');
+        }
+        meta[key] = value;
+    }
+    return { meta, body };
+}
+function toArray(value) {
+    if (!value)
+        return [];
+    if (Array.isArray(value))
+        return value;
+    return value
+        .split(',')
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+export class MarkdownKnowledgeLoader {
+    canLoad(filePath) {
+        return extname(filePath).toLowerCase() === '.md';
+    }
+    async load(filePath) {
+        const warnings = [];
+        const entries = [];
+        const sourceFiles = [];
+        if (!existsSync(filePath)) {
+            warnings.push(`Markdown file not found: ${filePath}`);
+            return { entries, warnings, sourceFiles };
+        }
+        sourceFiles.push(filePath);
+        let text;
+        try {
+            text = readFileSync(filePath, 'utf8');
+        }
+        catch (e) {
+            warnings.push(`Failed to read ${filePath}: ${e.message}`);
+            return { entries, warnings, sourceFiles };
+        }
+        const { meta, body } = parseFrontmatter(text);
+        const baseName = basename(filePath, '.md');
+        const titleFromBody = /^#\s+(.+)$/m.exec(body)?.[1]?.trim();
+        const entry = {
+            id: meta.id ? normalizeKnowledgeId(meta.id) : `doc.${toKebabCase(baseName)}`,
+            title: meta.title || titleFromBody || baseName,
+            type: meta.type || KnowledgeType.Technical,
+            priority: meta.priority || KnowledgePriority.Medium,
+            scope: Object.freeze(toArray(meta.scope)),
+            tags: Object.freeze(toArray(meta.tags).length > 0 ? toArray(meta.tags) : ['markdown', 'doc']),
+            appliesWhen: Object.freeze(toArray(meta.appliesWhen)),
+            content: body.trim(),
+            summary: meta.summary,
+            related: meta.related ? Object.freeze(toArray(meta.related)) : undefined,
+            source: { origin: filePath, loader: 'markdown' },
+        };
+        entries.push(entry);
+        return { entries, warnings, sourceFiles };
+    }
+}

package/dist/load/typescript-knowledge-loader.d.ts

@@ -0,0 +1,11 @@
+import { type IImportContext } from '@shrkcrft/core';
+import type { ILoadedKnowledge, IKnowledgeLoader } from './knowledge-loader.js';
+export declare class TypeScriptKnowledgeLoader implements IKnowledgeLoader {
+    private readonly _importContext;
+    constructor(options?: {
+        importContext?: IImportContext;
+    });
+    canLoad(filePath: string): boolean;
+    load(filePath: string): Promise<ILoadedKnowledge>;
+}
+//# sourceMappingURL=typescript-knowledge-loader.d.ts.map

package/dist/load/typescript-knowledge-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-knowledge-loader.d.ts","sourceRoot":"","sources":["../../src/load/typescript-knowledge-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAAc,MAAM,gBAAgB,CAAC;AAEjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAiChF,qBAAa,yBAA0B,YAAW,gBAAgB;IAChE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;gBAEhD,OAAO,GAAE;QAAE,aAAa,CAAC,EAAE,cAAc,CAAA;KAAO;IAI5D,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI5B,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAoCxD"}

package/dist/load/typescript-knowledge-loader.js

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import { extname } from 'node:path';
+import { safeImport } from '@shrkcrft/core';
+const TS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.mjs', '.cjs']);
+function isLikelyEntry(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const v = value;
+    return typeof v.id === 'string' && typeof v.title === 'string' && typeof v.content === 'string';
+}
+function collectEntriesFromModule(mod, entries) {
+    const seen = new Set();
+    const tryPush = (value) => {
+        if (!isLikelyEntry(value))
+            return;
+        if (seen.has(value.id))
+            return;
+        seen.add(value.id);
+        entries.push(value);
+    };
+    for (const key of Object.keys(mod)) {
+        const value = mod[key];
+        if (isLikelyEntry(value)) {
+            tryPush(value);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value)
+                tryPush(item);
+        }
+        else if (value && typeof value === 'object' && 'entries' in value) {
+            const inner = value.entries;
+            if (Array.isArray(inner)) {
+                for (const item of inner)
+                    tryPush(item);
+            }
+        }
+    }
+}
+export class TypeScriptKnowledgeLoader {
+    _importContext;
+    constructor(options = {}) {
+        this._importContext = options.importContext;
+    }
+    canLoad(filePath) {
+        return TS_EXTENSIONS.has(extname(filePath));
+    }
+    async load(filePath) {
+        const warnings = [];
+        const entries = [];
+        const sourceFiles = [];
+        if (!existsSync(filePath)) {
+            warnings.push(`Knowledge file not found: ${filePath}`);
+            return { entries, warnings, sourceFiles };
+        }
+        sourceFiles.push(filePath);
+        const result = this._importContext
+            ? await this._importContext.load(filePath)
+            : await safeImport(filePath, { skipExistsCheck: true });
+        if (!result.ok) {
+            const label = result.timedOut ? 'timed out importing' : 'Failed to import';
+            warnings.push(`${label} ${filePath}: ${result.error.message}`);
+            return { entries, warnings, sourceFiles };
+        }
+        collectEntriesFromModule(result.module, entries);
+        for (const entry of entries) {
+            if (!entry.source?.origin) {
+                entry.source = {
+                    origin: filePath,
+                    loader: 'typescript',
+                };
+            }
+        }
+        if (entries.length === 0) {
+            warnings.push(`No knowledge entries detected in ${filePath}`);
+        }
+        return { entries, warnings, sourceFiles };
+    }
+}

package/dist/model/action-hints.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Action guidance attached to a knowledge entry.
+ *
+ * The model exists so structured knowledge can answer "what should the agent
+ * do?" — not just "what is the rule?". Entries that are purely descriptive
+ * (e.g. project-overview, glossary) leave actionHints undefined.
+ */
+export interface IActionHintCommand {
+    /** A shell command. Placeholders like <task>, <repo>, <name> are conventional. */
+    command: string;
+    /** Why this command is run. */
+    purpose?: string;
+    /** Loose ordering hint: 'before' | 'during' | 'after' | free-form. */
+    when?: string;
+    /** True if the agent should treat this as mandatory for the flow. */
+    required?: boolean;
+}
+export interface IActionHintMcpTool {
+    /** MCP tool name (e.g. 'get_relevant_context'). */
+    tool: string;
+    purpose?: string;
+    when?: string;
+    required?: boolean;
+}
+export declare enum WritePolicy {
+    CliOnly = "cli-only",
+    None = "none",
+    /** Reserved — currently no MCP tool writes; kept so packs can declare intent. */
+    McpAllowed = "mcp-allowed"
+}
+export interface IActionHints {
+    /** CLI commands the agent should run. */
+    commands?: readonly IActionHintCommand[];
+    /** MCP tools the agent should call. */
+    mcpTools?: readonly IActionHintMcpTool[];
+    /**
+     * Ordered list of step ids (MCP tool names, CLI command strings, or pipeline
+     * step ids). Used by the context builder to render a "Preferred Flow"
+     * section. The highest-priority entry that defines a preferredFlow wins
+     * during aggregation.
+     */
+    preferredFlow?: readonly string[];
+    /** Things the agent must NOT do. Free-text. */
+    forbiddenActions?: readonly string[];
+    /** Template ids likely needed. */
+    relatedTemplates?: readonly string[];
+    /** Path convention ids likely needed. */
+    relatedPathConventions?: readonly string[];
+    /** Other knowledge entry ids to cross-reference. */
+    relatedKnowledge?: readonly string[];
+    /** Commands to run after generation. */
+    verificationCommands?: readonly string[];
+    /** Reminders about safety, replay, idempotency etc. */
+    safetyNotes?: readonly string[];
+    /** True if a human must review before any write. */
+    requiresHumanReview?: boolean;
+    /** Who is allowed to actually write files. */
+    writePolicy?: WritePolicy | 'cli-only' | 'mcp-allowed' | 'none';
+}
+export declare function hasActionHints(entry: {
+    actionHints?: IActionHints;
+}): boolean;
+//# sourceMappingURL=action-hints.d.ts.map

package/dist/model/action-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-hints.d.ts","sourceRoot":"","sources":["../../src/model/action-hints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,oBAAY,WAAW;IACrB,OAAO,aAAa;IACpB,IAAI,SAAS;IACb,iFAAiF;IACjF,UAAU,gBAAgB;CAC3B;AAED,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACzC,uCAAuC;IACvC,QAAQ,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACzC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,+CAA+C;IAC/C,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,kCAAkC;IAClC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,yCAAyC;IACzC,sBAAsB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,oDAAoD;IACpD,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,wCAAwC;IACxC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,uDAAuD;IACvD,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,oDAAoD;IACpD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,8CAA8C;IAC9C,WAAW,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,MAAM,CAAC;CACjE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,YAAY,CAAA;CAAE,GAAG,OAAO,CAgB7E"}

package/dist/model/action-hints.js

@@ -0,0 +1,23 @@
+export var WritePolicy;
+(function (WritePolicy) {
+    WritePolicy["CliOnly"] = "cli-only";
+    WritePolicy["None"] = "none";
+    /** Reserved — currently no MCP tool writes; kept so packs can declare intent. */
+    WritePolicy["McpAllowed"] = "mcp-allowed";
+})(WritePolicy || (WritePolicy = {}));
+export function hasActionHints(entry) {
+    const a = entry.actionHints;
+    if (!a)
+        return false;
+    return Boolean((a.commands && a.commands.length) ||
+        (a.mcpTools && a.mcpTools.length) ||
+        (a.preferredFlow && a.preferredFlow.length) ||
+        (a.forbiddenActions && a.forbiddenActions.length) ||
+        (a.relatedTemplates && a.relatedTemplates.length) ||
+        (a.relatedPathConventions && a.relatedPathConventions.length) ||
+        (a.relatedKnowledge && a.relatedKnowledge.length) ||
+        (a.verificationCommands && a.verificationCommands.length) ||
+        (a.safetyNotes && a.safetyNotes.length) ||
+        a.requiresHumanReview !== undefined ||
+        a.writePolicy !== undefined);
+}

package/dist/model/knowledge-base.d.ts

@@ -0,0 +1,6 @@
+import type { IKnowledgeEntry } from './knowledge-entry.js';
+export interface IKnowledgeBaseDefinition {
+    name?: string;
+    entries: readonly IKnowledgeEntry[];
+}
+//# sourceMappingURL=knowledge-base.d.ts.map

package/dist/model/knowledge-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-base.d.ts","sourceRoot":"","sources":["../../src/model/knowledge-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CACrC"}

package/dist/model/knowledge-base.js

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

package/dist/model/knowledge-entry.d.ts

@@ -0,0 +1,84 @@
+import type { KnowledgeType } from './knowledge-type.js';
+import type { KnowledgePriority } from './knowledge-priority.js';
+import type { IActionHints } from './action-hints.js';
+export interface IKnowledgeExample {
+    title?: string;
+    description?: string;
+    code?: string;
+    language?: string;
+}
+export interface IKnowledgeSource {
+    /** Originating file path or URL. */
+    origin?: string;
+    /** Optional identifier of the loader that produced this entry. */
+    loader?: string;
+}
+/**
+ * Structured reference attached to a knowledge entry.
+ *
+ * References make the entry verifiable: stale-check confirms each target
+ * still exists; rename advisory reports affected entries when a target is
+ * renamed.
+ */
+export type KnowledgeReferenceKind = 'file' | 'directory' | 'symbol' | 'command' | 'template' | 'playbook' | 'construct' | 'helper' | 'policy' | 'boundary-rule' | 'path-convention' | 'package' | 'url';
+export interface IKnowledgeReference {
+    kind: KnowledgeReferenceKind;
+    /** Project-relative path for `file` / `directory`. */
+    path?: string;
+    /** Symbol name for `symbol` references (function, class, type). */
+    symbol?: string;
+    /** Id for `command` / `template` / `playbook` / `construct` / `helper` / `policy` / `boundary-rule` / `path-convention` / `package`. */
+    id?: string;
+    /** Raw command line for `command` (alternative to `id`). */
+    command?: string;
+    /** Whether the stale-check treats a missing target as an error (default false). */
+    required?: boolean;
+    /** Free-form note carried verbatim. */
+    note?: string;
+}
+/**
+ * Anchor — a named point inside or related to an entry. Anchors are what
+ * the rename advisory tool updates when a target is moved.
+ */
+export type KnowledgeAnchorKind = 'file' | 'symbol' | 'command' | 'construct' | 'template' | 'helper' | 'playbook' | 'policy';
+export interface IKnowledgeAnchor {
+    id: string;
+    kind: KnowledgeAnchorKind;
+    path?: string;
+    symbol?: string;
+    targetId?: string;
+    description?: string;
+}
+export interface IKnowledgeEntry {
+    id: string;
+    title: string;
+    type: KnowledgeType | string;
+    priority: KnowledgePriority | string;
+    scope: readonly string[];
+    tags: readonly string[];
+    appliesWhen: readonly string[];
+    content: string;
+    summary?: string;
+    examples?: readonly IKnowledgeExample[];
+    related?: readonly string[];
+    source?: IKnowledgeSource;
+    metadata?: Readonly<Record<string, unknown>>;
+    /**
+     * Optional structured action guidance for AI agents. When present, the
+     * context builder surfaces commands / MCP tools / forbidden actions /
+     * verification commands etc. so the agent does not have to guess the flow.
+     */
+    actionHints?: IActionHints;
+    /**
+     * Optional verifiable references to repo artefacts.
+     *
+     * Optional — entries that omit this field still load.
+     */
+    references?: readonly IKnowledgeReference[];
+    /**
+     * Optional named anchors describing what the entry is *about*.
+     * Anchors get updated by `shrk knowledge rename-symbol|rename-file`.
+     */
+    anchors?: readonly IKnowledgeAnchor[];
+}
+//# sourceMappingURL=knowledge-entry.d.ts.map

package/dist/model/knowledge-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-entry.d.ts","sourceRoot":"","sources":["../../src/model/knowledge-entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAC9B,MAAM,GACN,WAAW,GACX,QAAQ,GACR,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,eAAe,GACf,iBAAiB,GACjB,SAAS,GACT,KAAK,CAAC;AAEV,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wIAAwI;IACxI,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,QAAQ,GACR,SAAS,GACT,WAAW,GACX,UAAU,GACV,QAAQ,GACR,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC;IAC7B,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACrC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACxC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C;;;;OAIG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC5C;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACvC"}

package/dist/model/knowledge-entry.js

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

package/dist/model/knowledge-priority.d.ts

@@ -0,0 +1,9 @@
+export declare enum KnowledgePriority {
+    Critical = "critical",
+    High = "high",
+    Medium = "medium",
+    Low = "low"
+}
+export declare const PRIORITY_WEIGHTS: Readonly<Record<KnowledgePriority, number>>;
+export declare function priorityWeight(priority: KnowledgePriority | undefined): number;
+//# sourceMappingURL=knowledge-priority.d.ts.map

package/dist/model/knowledge-priority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-priority.d.ts","sourceRoot":"","sources":["../../src/model/knowledge-priority.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,GAAG,QAAQ;CACZ;AAED,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAKvE,CAAC;AAEH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAE9E"}

package/dist/model/knowledge-priority.js

@@ -0,0 +1,16 @@
+export var KnowledgePriority;
+(function (KnowledgePriority) {
+    KnowledgePriority["Critical"] = "critical";
+    KnowledgePriority["High"] = "high";
+    KnowledgePriority["Medium"] = "medium";
+    KnowledgePriority["Low"] = "low";
+})(KnowledgePriority || (KnowledgePriority = {}));
+export const PRIORITY_WEIGHTS = Object.freeze({
+    [KnowledgePriority.Critical]: 100,
+    [KnowledgePriority.High]: 70,
+    [KnowledgePriority.Medium]: 40,
+    [KnowledgePriority.Low]: 10,
+});
+export function priorityWeight(priority) {
+    return PRIORITY_WEIGHTS[priority ?? KnowledgePriority.Medium];
+}

package/dist/model/knowledge-query.d.ts

@@ -0,0 +1,17 @@
+export interface IKnowledgeQuery {
+    /** Free-text query (matched against title/summary/content/tags). */
+    query?: string;
+    /** Restrict by knowledge type. */
+    types?: readonly string[];
+    /** Restrict by scope (framework/area). */
+    scope?: readonly string[];
+    /** Tag filter (AND). */
+    tags?: readonly string[];
+    /** appliesWhen filter (any-match). */
+    appliesWhen?: readonly string[];
+    /** Minimum priority threshold. */
+    minPriority?: string;
+    /** Limit on returned entries. */
+    limit?: number;
+}
+//# sourceMappingURL=knowledge-query.d.ts.map

package/dist/model/knowledge-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-query.d.ts","sourceRoot":"","sources":["../../src/model/knowledge-query.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,wBAAwB;IACxB,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,sCAAsC;IACtC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/model/knowledge-query.js

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

package/dist/model/knowledge-search-result.d.ts

@@ -0,0 +1,11 @@
+import type { IKnowledgeEntry } from './knowledge-entry.js';
+export interface IKnowledgeMatchReason {
+    field: string;
+    match: string;
+}
+export interface IKnowledgeSearchResult {
+    entry: IKnowledgeEntry;
+    score: number;
+    reasons: readonly IKnowledgeMatchReason[];
+}
+//# sourceMappingURL=knowledge-search-result.d.ts.map

package/dist/model/knowledge-search-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-search-result.d.ts","sourceRoot":"","sources":["../../src/model/knowledge-search-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC3C"}

package/dist/model/knowledge-search-result.js

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

package/dist/model/knowledge-type.d.ts

@@ -0,0 +1,25 @@
+export declare enum KnowledgeType {
+    Rule = "rule",
+    Path = "path",
+    Template = "template",
+    Architecture = "architecture",
+    Technical = "technical",
+    Business = "business",
+    Command = "command",
+    Environment = "environment",
+    Dependency = "dependency",
+    Feature = "feature",
+    Task = "task",
+    Warning = "warning",
+    Decision = "decision",
+    Convention = "convention",
+    Workflow = "workflow",
+    Testing = "testing",
+    Security = "security",
+    Deployment = "deployment",
+    Integration = "integration",
+    Custom = "custom"
+}
+export declare const ALL_KNOWLEDGE_TYPES: readonly KnowledgeType[];
+export declare function isKnowledgeType(value: unknown): value is KnowledgeType;
+//# sourceMappingURL=knowledge-type.d.ts.map

package/dist/model/knowledge-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-type.d.ts","sourceRoot":"","sources":["../../src/model/knowledge-type.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,YAAY,iBAAiB;IAC7B,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,UAAU,eAAe;IACzB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,UAAU,eAAe;IACzB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,UAAU,eAAe;IACzB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,mBAAmB,EAAE,SAAS,aAAa,EAEvD,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE"}

package/dist/model/knowledge-type.js

@@ -0,0 +1,27 @@
+export var KnowledgeType;
+(function (KnowledgeType) {
+    KnowledgeType["Rule"] = "rule";
+    KnowledgeType["Path"] = "path";
+    KnowledgeType["Template"] = "template";
+    KnowledgeType["Architecture"] = "architecture";
+    KnowledgeType["Technical"] = "technical";
+    KnowledgeType["Business"] = "business";
+    KnowledgeType["Command"] = "command";
+    KnowledgeType["Environment"] = "environment";
+    KnowledgeType["Dependency"] = "dependency";
+    KnowledgeType["Feature"] = "feature";
+    KnowledgeType["Task"] = "task";
+    KnowledgeType["Warning"] = "warning";
+    KnowledgeType["Decision"] = "decision";
+    KnowledgeType["Convention"] = "convention";
+    KnowledgeType["Workflow"] = "workflow";
+    KnowledgeType["Testing"] = "testing";
+    KnowledgeType["Security"] = "security";
+    KnowledgeType["Deployment"] = "deployment";
+    KnowledgeType["Integration"] = "integration";
+    KnowledgeType["Custom"] = "custom";
+})(KnowledgeType || (KnowledgeType = {}));
+export const ALL_KNOWLEDGE_TYPES = Object.freeze(Object.values(KnowledgeType));
+export function isKnowledgeType(value) {
+    return typeof value === 'string' && ALL_KNOWLEDGE_TYPES.includes(value);
+}

package/dist/search/knowledge-filter.d.ts

@@ -0,0 +1,9 @@
+import type { IKnowledgeEntry } from '../model/knowledge-entry.js';
+export interface KnowledgeFilterOptions {
+    types?: readonly string[];
+    scope?: readonly string[];
+    tags?: readonly string[];
+    appliesWhen?: readonly string[];
+}
+export declare function filterKnowledge(entries: readonly IKnowledgeEntry[], options: KnowledgeFilterOptions): IKnowledgeEntry[];
+//# sourceMappingURL=knowledge-filter.d.ts.map

package/dist/search/knowledge-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-filter.d.ts","sourceRoot":"","sources":["../../src/search/knowledge-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,OAAO,EAAE,sBAAsB,GAC9B,eAAe,EAAE,CAanB"}

package/dist/search/knowledge-filter.js

@@ -0,0 +1,15 @@
+export function filterKnowledge(entries, options) {
+    return entries.filter((entry) => {
+        if (options.types?.length && !options.types.includes(String(entry.type)))
+            return false;
+        if (options.scope?.length && !options.scope.some((s) => entry.scope.includes(s)))
+            return false;
+        if (options.tags?.length && !options.tags.every((t) => entry.tags.includes(t)))
+            return false;
+        if (options.appliesWhen?.length &&
+            !options.appliesWhen.some((a) => entry.appliesWhen.includes(a))) {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/search/knowledge-search.d.ts

@@ -0,0 +1,5 @@
+import type { IKnowledgeEntry } from '../model/knowledge-entry.js';
+import type { IKnowledgeQuery } from '../model/knowledge-query.js';
+import type { IKnowledgeSearchResult } from '../model/knowledge-search-result.js';
+export declare function searchKnowledge(entries: readonly IKnowledgeEntry[], query: IKnowledgeQuery): IKnowledgeSearchResult[];
+//# sourceMappingURL=knowledge-search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-search.d.ts","sourceRoot":"","sources":["../../src/search/knowledge-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAGlF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,KAAK,EAAE,eAAe,GACrB,sBAAsB,EAAE,CAG1B"}

package/dist/search/knowledge-search.js

@@ -0,0 +1,5 @@
+import { KnowledgeIndex } from "../index/knowledge-index.js";
+export function searchKnowledge(entries, query) {
+    const index = new KnowledgeIndex(entries);
+    return index.search(query);
+}

package/dist/validate/validate-knowledge-entries.d.ts

@@ -0,0 +1,29 @@
+import type { IKnowledgeEntry } from '../model/knowledge-entry.js';
+export interface IKnowledgeValidationIssue {
+    /** Stable identifier for the issue category. */
+    code: 'missing-id' | 'invalid-id-format' | 'duplicate-id' | 'missing-title' | 'missing-content' | 'missing-type' | 'invalid-type' | 'invalid-priority';
+    /** Affected entry id (or '?' if unknown). */
+    entryId: string;
+    /** Source file path if available. */
+    source?: string;
+    /** Human-readable message. */
+    message: string;
+    /** Severity hint. */
+    severity: 'error' | 'warning';
+}
+export interface IKnowledgeValidationResult {
+    valid: boolean;
+    issues: IKnowledgeValidationIssue[];
+    /** Entries with the first-seen winner for each id (duplicates dropped). */
+    uniqueEntries: IKnowledgeEntry[];
+}
+/**
+ * Validate a list of knowledge entries. Catches the classic problems:
+ *   - missing or malformed id
+ *   - duplicate ids (warning — first occurrence wins)
+ *   - missing title/content/type
+ *   - unknown type (warning — custom types are allowed but get flagged)
+ *   - unknown priority (error)
+ */
+export declare function validateKnowledgeEntries(entries: readonly IKnowledgeEntry[]): IKnowledgeValidationResult;
+//# sourceMappingURL=validate-knowledge-entries.d.ts.map

package/dist/validate/validate-knowledge-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-knowledge-entries.d.ts","sourceRoot":"","sources":["../../src/validate/validate-knowledge-entries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAInE,MAAM,WAAW,yBAAyB;IACxC,gDAAgD;IAChD,IAAI,EACA,YAAY,GACZ,mBAAmB,GACnB,cAAc,GACd,eAAe,GACf,iBAAiB,GACjB,cAAc,GACd,cAAc,GACd,kBAAkB,CAAC;IACvB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,qBAAqB;IACrB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,yBAAyB,EAAE,CAAC;IACpC,2EAA2E;IAC3E,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC;AAKD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,0BAA0B,CA4F5B"}