@knowledgine/cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,26 @@
+/**
+ * A skill template contains the SKILL.md content and any reference files
+ * that should be written alongside it.
+ */
+export interface SkillTemplate {
+    /** Content of the SKILL.md file */
+    skillMd: string;
+    /** Map of filename → content for reference files placed in a references/ subdirectory */
+    references: Record<string, string>;
+}
+/**
+ * All available skill names.
+ */
+export declare const SKILL_NAMES: readonly ["knowledgine-capture", "knowledgine-recall", "knowledgine-suggest", "knowledgine-explain", "knowledgine-debrief", "knowledgine-ingest", "knowledgine-feedback"];
+export type SkillName = (typeof SKILL_NAMES)[number];
+/**
+ * Returns the template for a single skill by name.
+ *
+ * @throws {Error} If the skill name is not recognized.
+ */
+export declare function getSkillTemplate(name: SkillName): SkillTemplate;
+/**
+ * Returns all skill templates as a record keyed by skill name.
+ */
+export declare function getAllSkillTemplates(): Record<SkillName, SkillTemplate>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/skills/index.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,yFAAyF;IACzF,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,2KAQd,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAiCrD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,aAAa,CAM/D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,CAEvE"}

package/dist/templates/skills/index.js

@@ -0,0 +1,75 @@
+import { SKILL_MD as CAPTURE_MD } from "./knowledgine-capture/skill-md.js";
+import { REFERENCES as CAPTURE_REFS } from "./knowledgine-capture/references.js";
+import { SKILL_MD as RECALL_MD } from "./knowledgine-recall/skill-md.js";
+import { REFERENCES as RECALL_REFS } from "./knowledgine-recall/references.js";
+import { SKILL_MD as SUGGEST_MD } from "./knowledgine-suggest/skill-md.js";
+import { REFERENCES as SUGGEST_REFS } from "./knowledgine-suggest/references.js";
+import { SKILL_MD as EXPLAIN_MD } from "./knowledgine-explain/skill-md.js";
+import { REFERENCES as EXPLAIN_REFS } from "./knowledgine-explain/references.js";
+import { SKILL_MD as DEBRIEF_MD } from "./knowledgine-debrief/skill-md.js";
+import { REFERENCES as DEBRIEF_REFS } from "./knowledgine-debrief/references.js";
+import { SKILL_MD as INGEST_MD } from "./knowledgine-ingest/skill-md.js";
+import { REFERENCES as INGEST_REFS } from "./knowledgine-ingest/references.js";
+import { SKILL_MD as FEEDBACK_MD } from "./knowledgine-feedback/skill-md.js";
+import { REFERENCES as FEEDBACK_REFS } from "./knowledgine-feedback/references.js";
+/**
+ * All available skill names.
+ */
+export const SKILL_NAMES = [
+    "knowledgine-capture",
+    "knowledgine-recall",
+    "knowledgine-suggest",
+    "knowledgine-explain",
+    "knowledgine-debrief",
+    "knowledgine-ingest",
+    "knowledgine-feedback",
+];
+const SKILL_TEMPLATES = {
+    "knowledgine-capture": {
+        skillMd: CAPTURE_MD,
+        references: CAPTURE_REFS,
+    },
+    "knowledgine-recall": {
+        skillMd: RECALL_MD,
+        references: RECALL_REFS,
+    },
+    "knowledgine-suggest": {
+        skillMd: SUGGEST_MD,
+        references: SUGGEST_REFS,
+    },
+    "knowledgine-explain": {
+        skillMd: EXPLAIN_MD,
+        references: EXPLAIN_REFS,
+    },
+    "knowledgine-debrief": {
+        skillMd: DEBRIEF_MD,
+        references: DEBRIEF_REFS,
+    },
+    "knowledgine-ingest": {
+        skillMd: INGEST_MD,
+        references: INGEST_REFS,
+    },
+    "knowledgine-feedback": {
+        skillMd: FEEDBACK_MD,
+        references: FEEDBACK_REFS,
+    },
+};
+/**
+ * Returns the template for a single skill by name.
+ *
+ * @throws {Error} If the skill name is not recognized.
+ */
+export function getSkillTemplate(name) {
+    const template = SKILL_TEMPLATES[name];
+    if (!template) {
+        throw new Error(`Unknown skill: ${name}. Available skills: ${SKILL_NAMES.join(", ")}`);
+    }
+    return template;
+}
+/**
+ * Returns all skill templates as a record keyed by skill name.
+ */
+export function getAllSkillTemplates() {
+    return { ...SKILL_TEMPLATES };
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/skills/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/skills/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,QAAQ,IAAI,SAAS,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,QAAQ,IAAI,SAAS,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,QAAQ,IAAI,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAanF;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,qBAAqB;IACrB,oBAAoB;IACpB,qBAAqB;IACrB,qBAAqB;IACrB,qBAAqB;IACrB,oBAAoB;IACpB,sBAAsB;CACd,CAAC;AAIX,MAAM,eAAe,GAAqC;IACxD,qBAAqB,EAAE;QACrB,OAAO,EAAE,UAAU;QACnB,UAAU,EAAE,YAAY;KACzB;IACD,oBAAoB,EAAE;QACpB,OAAO,EAAE,SAAS;QAClB,UAAU,EAAE,WAAW;KACxB;IACD,qBAAqB,EAAE;QACrB,OAAO,EAAE,UAAU;QACnB,UAAU,EAAE,YAAY;KACzB;IACD,qBAAqB,EAAE;QACrB,OAAO,EAAE,UAAU;QACnB,UAAU,EAAE,YAAY;KACzB;IACD,qBAAqB,EAAE;QACrB,OAAO,EAAE,UAAU;QACnB,UAAU,EAAE,YAAY;KACzB;IACD,oBAAoB,EAAE;QACpB,OAAO,EAAE,SAAS;QAClB,UAAU,EAAE,WAAW;KACxB;IACD,sBAAsB,EAAE;QACtB,OAAO,EAAE,WAAW;QACpB,UAAU,EAAE,aAAa;KAC1B;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAe;IAC9C,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,kBAAkB,IAAI,uBAAuB,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACzF,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,EAAE,GAAG,eAAe,EAAE,CAAC;AAChC,CAAC"}

package/dist/templates/skills/knowledgine-capture/references.d.ts

@@ -0,0 +1,2 @@
+export declare const REFERENCES: Record<string, string>;
+//# sourceMappingURL=references.d.ts.map

package/dist/templates/skills/knowledgine-capture/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-capture/references.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA8Z7C,CAAC"}

package/dist/templates/skills/knowledgine-capture/references.js

@@ -0,0 +1,414 @@
+export const REFERENCES = {
+    "capture-guide.md": `# Capture Guide
+
+Detailed guidance for each of the six capture trigger types.
+
+---
+
+## 1. Bug Fix
+
+**When**: You diagnosed and resolved a defect.
+
+**What to include**:
+- Exact error message or symptom
+- Root cause (not just "it was broken")
+- The fix applied
+- How to avoid the bug in future
+
+**Example**:
+\`\`\`
+Problem: "Cannot read properties of undefined (reading 'id')" at user.ts:42.
+
+Root cause: getUser() returned undefined when the database row did not exist, but the
+caller assumed a non-null return value.
+
+Fix: Added null check in getUser() and updated the return type to User | undefined.
+Updated all callers to handle the undefined case.
+
+Prevention: Avoid non-null assertions (!). Return undefined explicitly and propagate the
+type to callers.
+\`\`\`
+
+Tags: \`bug-fix\`, \`typescript\`, \`null-safety\`
+
+---
+
+## 2. Design Decision
+
+**When**: You chose one architectural or implementation approach over alternatives.
+
+**What to include**:
+- The decision made (concise summary in the title)
+- Options that were considered
+- The chosen approach
+- Reasoning and trade-offs
+- Any constraints that drove the decision
+
+**Example**:
+\`\`\`
+Decision: Use Zod for runtime API response validation instead of manual type guards.
+
+Options considered:
+A) Manual type guards — verbose, error-prone to maintain
+B) Zod schema validation — declarative, generates TypeScript types automatically
+C) io-ts — functional style, steep learning curve for the team
+
+Chosen: Zod (option B). The automatic type inference reduces duplication between
+runtime validation and TypeScript types. Team is already familiar with Zod from
+form validation.
+\`\`\`
+
+Tags: \`design-decision\`, \`typescript\`, \`validation\`
+
+---
+
+## 3. Pattern Discovery
+
+**When**: You identified a reusable code pattern applicable beyond the current file.
+
+**What to include**:
+- Pattern name (if it has one)
+- Problem the pattern solves
+- Template/skeleton code
+- Where to apply it
+- Caveats or limitations
+
+**Example**:
+\`\`\`
+Pattern: Repository layer with in-memory cache for read-heavy entities.
+
+When to use: Entity reads are >10x more frequent than writes and data fits in memory.
+
+Template:
+  class CachedRepository<T> {
+    private cache = new Map<string, T>();
+    find(id: string): T | undefined { return this.cache.get(id); }
+    store(id: string, entity: T): void { this.cache.set(id, entity); }
+    invalidate(id: string): void { this.cache.delete(id); }
+  }
+
+Caveat: Cache must be invalidated on writes; not suitable for distributed deployments
+without a shared cache layer.
+\`\`\`
+
+Tags: \`pattern\`, \`caching\`, \`architecture\`
+
+---
+
+## 4. Troubleshooting
+
+**When**: You worked through a multi-step diagnostic process to resolve an issue.
+
+**What to include**:
+- Initial symptom
+- Hypotheses tested and results
+- False leads (so others don't repeat them)
+- Final diagnosis
+- Resolution steps
+
+**Example**:
+\`\`\`
+Symptom: knowledgine start fails with "SQLITE_ERROR: no such module: vec0" after
+upgrading Node.js from 18 to 20.
+
+Hypotheses tested:
+- Reinstalled sqlite-vec package — no change
+- Cleared node_modules and reinstalled — no change
+- Downgraded back to Node 18 — resolved the issue
+
+Diagnosis: Native module compiled for Node 18 ABI. Node 20 uses a different ABI
+(NODE_MODULE_VERSION 115 vs 108).
+
+Resolution: Run "npm rebuild" after upgrading Node.js to recompile native modules.
+\`\`\`
+
+Tags: \`troubleshooting\`, \`sqlite\`, \`native-modules\`, \`nodejs\`
+
+---
+
+## 5. External Knowledge
+
+**When**: You applied insights from documentation, articles, blog posts, or Stack Overflow.
+
+**What to include**:
+- Source URL or reference
+- Key insight extracted
+- How you applied it to this project
+- Any caveats specific to this codebase
+
+**Example**:
+\`\`\`
+Source: https://nodejs.org/api/esm.html#esm_mandatory_file_extensions
+
+Insight: In ESM (type: "module" in package.json), import paths MUST include the .js
+extension even for TypeScript files. The TypeScript compiler emits .js extensions in
+output but the source .ts files must reference .js for tsc to resolve them correctly.
+
+Applied: Updated all internal imports in packages/cli/src to use .js extension.
+\`\`\`
+
+Tags: \`external-knowledge\`, \`esm\`, \`typescript\`
+
+---
+
+## 6. Refactoring
+
+**When**: You improved the structure or quality of existing code.
+
+**What to include**:
+- What was wrong before
+- What you changed
+- The improvement achieved (readability, performance, maintainability)
+- Any risks or trade-offs
+
+**Example**:
+\`\`\`
+Before: Single 400-line setupCommand() function with nested conditionals handling all
+target types inline.
+
+After: Extracted per-target config builders into a TARGET_HANDLERS map. Each handler
+is a pure function returning McpConfig. The main command orchestrates selection and
+writing only.
+
+Improvement: Adding a new target now requires only adding one entry to TARGET_HANDLERS
+rather than editing the main function. Test coverage became straightforward.
+\`\`\`
+
+Tags: \`refactoring\`, \`architecture\`
+`,
+    "tag-taxonomy.md": `# Tag Taxonomy
+
+Standard tags for knowledgine knowledge captures. Use 2–5 tags per capture.
+Choose the most specific applicable tags; avoid generic tags like "code" or "misc".
+
+---
+
+## Primary Category Tags (choose one)
+
+| Tag | Use for |
+|-----|---------|
+| \`bug-fix\` | Resolved defects with root cause analysis |
+| \`design-decision\` | Architectural or implementation choices with reasoning |
+| \`pattern\` | Reusable code or design patterns |
+| \`troubleshooting\` | Multi-step diagnostic processes |
+| \`external-knowledge\` | Insights from external sources (docs, articles, SO) |
+| \`refactoring\` | Code quality improvements |
+
+## Domain Tags (choose 0–3)
+
+### Languages & Runtimes
+| Tag | Use for |
+|-----|---------|
+| \`typescript\` | TypeScript-specific patterns, type system |
+| \`javascript\` | JavaScript-specific patterns |
+| \`nodejs\` | Node.js runtime, native modules, ESM |
+| \`sql\` | SQL queries, schema design |
+| \`bash\` | Shell scripts, CLI tools |
+
+### Quality & Safety
+| Tag | Use for |
+|-----|---------|
+| \`null-safety\` | Null/undefined handling, optional chaining |
+| \`type-safety\` | TypeScript strict mode, type guards |
+| \`error-handling\` | Error propagation, try/catch patterns |
+| \`validation\` | Input validation, schema validation |
+| \`security\` | Auth, injection prevention, secrets management |
+| \`testing\` | Test patterns, test utilities, coverage |
+
+### Architecture
+| Tag | Use for |
+|-----|---------|
+| \`architecture\` | High-level structural decisions |
+| \`api-design\` | REST, RPC, GraphQL interface design |
+| \`database\` | Database schema, migrations, queries |
+| \`caching\` | In-memory or distributed caching |
+| \`async\` | Async/await patterns, concurrency |
+
+### Infrastructure & Tooling
+| Tag | Use for |
+|-----|---------|
+| \`build\` | Build system, bundler configuration |
+| \`ci-cd\` | CI/CD pipelines, GitHub Actions |
+| \`devops\` | Deployment, infrastructure as code |
+| \`dependencies\` | Package management, version upgrades |
+| \`native-modules\` | Native Node.js addons, ABI compatibility |
+| \`esm\` | ES modules, import/export |
+| \`performance\` | Optimization, profiling, benchmarks |
+| \`memory\` | Memory management, leak detection |
+
+### Project-Specific
+| Tag | Use for |
+|-----|---------|
+| \`sqlite\` | SQLite, sqlite-vec, FTS5 |
+| \`mcp\` | Model Context Protocol integration |
+| \`embedding\` | Vector embeddings, semantic search |
+| \`entity-extraction\` | Named entity recognition, graph |
+| \`ingest\` | Knowledge ingestion pipeline |
+
+---
+
+## Tagging Examples
+
+| Scenario | Tags |
+|----------|------|
+| Fixed a TypeScript null reference error | \`bug-fix\`, \`typescript\`, \`null-safety\` |
+| Decided to use Zod for validation | \`design-decision\`, \`validation\`, \`typescript\` |
+| Found ESM import extension pattern | \`external-knowledge\`, \`esm\`, \`nodejs\` |
+| Optimized SQLite FTS5 query | \`performance\`, \`sqlite\`, \`database\` |
+| Refactored command handler structure | \`refactoring\`, \`architecture\` |
+`,
+    "format-examples.md": `# Format Examples
+
+Concrete examples of well-formatted knowledge captures.
+
+---
+
+## Example 1: Bug Fix (TypeScript)
+
+**Title**: Fix "object is possibly undefined" in KnowledgeRepository.getById
+
+**Tags**: \`bug-fix\`, \`typescript\`, \`null-safety\`
+
+**Content**:
+\`\`\`
+Problem: TypeScript error "object is possibly 'undefined'" when accessing note.id after
+calling repository.getById(). The method signature returned Note | undefined but all
+call sites assumed Note.
+
+Root cause: The method was added when the codebase was less strict. The return type
+correctly reflects that a record might not exist, but call sites were not updated.
+
+Fix:
+1. Updated all call sites to handle the undefined case explicitly:
+   const note = repository.getById(id);
+   if (!note) { throw new Error(\`Note \${id} not found\`); }
+2. Added a getByIdOrThrow() helper for cases where undefined is a programming error.
+
+Prevention: Avoid non-null assertions (!). Add repository methods with explicit error
+semantics (OrThrow suffix) so callers choose their error handling strategy.
+\`\`\`
+
+---
+
+## Example 2: Design Decision (Architecture)
+
+**Title**: Use append-only markers in CLAUDE.md for knowledgine rules section
+
+**Tags**: \`design-decision\`, \`architecture\`
+
+**Content**:
+\`\`\`
+Decision: Wrap the injected rules section in HTML comment markers
+<!-- knowledgine:rules:start --> and <!-- knowledgine:rules:end --> rather than
+replacing the entire file or using a separate file.
+
+Options considered:
+A) Separate .knowledgine/RULES.md file — requires agent to know about the extra file
+B) Replace entire CLAUDE.md — destroys user customizations on re-run
+C) Append-only (no markers) — cannot update or remove without leaving duplicates
+D) Marked section (chosen) — idempotent updates, preserves surrounding content
+
+Chosen: Option D. The markers allow the CLI to find and replace exactly the
+knowledgine section on subsequent runs while leaving user-written content intact.
+This makes setup re-runnable and upgrade-safe.
+
+Trade-off: If the user manually removes one marker, the update logic will break.
+Documented in the README as a known limitation.
+\`\`\`
+
+---
+
+## Example 3: Troubleshooting (Native Module)
+
+**Title**: sqlite-vec fails after Node.js major version upgrade — run npm rebuild
+
+**Tags**: \`troubleshooting\`, \`sqlite\`, \`native-modules\`, \`nodejs\`
+
+**Content**:
+\`\`\`
+Symptom: "Error: The specified module could not be found" (Windows) or
+"invalid ELF header" (Linux) when loading sqlite-vec after upgrading Node.js.
+
+Root cause: Native addons (.node files) are compiled against a specific Node.js ABI
+version (NODE_MODULE_VERSION). Upgrading Node.js changes the ABI, making pre-compiled
+binaries incompatible.
+
+Diagnosis steps:
+1. Confirmed error occurs only after Node upgrade, not on fresh install
+2. Checked node-gyp output: "gyp info using node@20.x.x | ABI 115"
+3. Found existing .node file compiled for ABI 108 (Node 18)
+
+Resolution: Run \`npm rebuild\` (or \`pnpm rebuild\`) after every Node.js major version
+upgrade. This recompiles all native modules for the current ABI.
+
+For CI: Pin NODE_MODULE_VERSION in cache keys to avoid stale compiled artifacts.
+\`\`\`
+
+---
+
+## Example 4: Pattern Discovery
+
+**Title**: Pattern: early-return guard clauses to eliminate deep nesting
+
+**Tags**: \`pattern\`, \`refactoring\`
+
+**Content**:
+\`\`\`
+Problem: Functions with multiple validation steps produce deeply nested if/else blocks
+that are hard to read and test independently.
+
+Pattern: Use guard clauses (early returns) to validate preconditions at the top of the
+function, keeping the happy path at the minimum indent level.
+
+Before:
+  function processNote(note: Note | undefined) {
+    if (note) {
+      if (note.content) {
+        if (note.content.length > 0) {
+          // actual logic here — 3 levels deep
+        }
+      }
+    }
+  }
+
+After:
+  function processNote(note: Note | undefined) {
+    if (!note) return;
+    if (!note.content) return;
+    if (note.content.length === 0) return;
+    // actual logic here — top level
+  }
+
+Applies to: Any function with multiple nullable inputs or precondition checks.
+Caveat: When early returns have side effects (logging, metrics), make that explicit.
+\`\`\`
+
+---
+
+## Example 5: External Knowledge
+
+**Title**: ESM requires .js extension in TypeScript import paths even for .ts source files
+
+**Tags**: \`external-knowledge\`, \`esm\`, \`typescript\`, \`nodejs\`
+
+**Content**:
+\`\`\`
+Source: https://www.typescriptlang.org/docs/handbook/esm-node.html
+
+Insight: When compiling TypeScript to ESM (module: "NodeNext" or "ESNext" + type:
+"module" in package.json), import paths MUST end in .js — not .ts — even when the
+source file is .ts.
+
+Reason: TypeScript does not rename import extensions at compile time. The runtime
+(Node.js ESM loader) looks for .js files. TypeScript resolves .ts source files when
+you write \`import foo from "./foo.js"\` — it knows that .js refers to the compiled .ts.
+
+Applied to this project: All internal imports in packages/cli/src/ use .js extensions.
+Forgetting this causes "Cannot find module" at runtime despite TypeScript compiling
+successfully (because tsc resolves the type but Node.js cannot find the file).
+
+Gotcha: \`import type\` paths also need .js extensions in strict ESM mode.
+\`\`\`
+`,
+};
+//# sourceMappingURL=references.js.map

package/dist/templates/skills/knowledgine-capture/references.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.js","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-capture/references.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAA2B;IAChD,kBAAkB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgLrB;IAEC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFpB;IAEC,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwJvB;CACA,CAAC"}

package/dist/templates/skills/knowledgine-capture/skill-md.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILL_MD = "---\nname: knowledgine-capture\ndescription: >\n  Record knowledge to the local knowledge base after solving problems, making design\n  decisions, or discovering reusable patterns. Invoke whenever you have just fixed a bug,\n  made an architectural choice, found a reusable pattern, learned something from external\n  sources, or completed a refactoring. Capturing while context is fresh prevents knowledge\n  loss across sessions.\n---\n# knowledgine-capture\n\n## Purpose\n\nPersist valuable learnings from the current session into the local knowledge base so they\nare available for future sessions and team members. The knowledge base is only as useful\nas what is recorded into it.\n\n## When to Use\n\nCapture knowledge when **any** of the following events occur in the session:\n\n1. **Bug fix** \u2014 You identified a root cause and applied a solution\n2. **Design decision** \u2014 You chose one approach over alternatives with reasoning\n3. **Pattern discovery** \u2014 You found a reusable pattern worth applying elsewhere\n4. **Troubleshooting** \u2014 You worked through a non-obvious diagnosis process\n5. **External knowledge** \u2014 You applied insights from documentation, articles, or Stack Overflow\n6. **Refactoring** \u2014 You improved existing code with a clear before/after\n\n## When NOT to Use\n\n- Trivial edits (typo fixes, formatting changes) that contain no transferable insight\n- Highly project-specific one-off changes with no reuse value\n- Duplicate entries: first search with `search_knowledge` to check if the knowledge already exists\n\n## How to Capture (MCP Tool)\n\nUse the `capture_knowledge` MCP tool:\n\n```\ncapture_knowledge(\n  content: string,   // Full explanation: problem + solution + context\n  title: string,     // Short descriptive title (max ~80 chars)\n  tags: string[],    // 2\u20135 tags from the standard taxonomy\n  source?: string    // Optional: URL, filename, or reference source\n)\n```\n\n## How to Capture (CLI Alternative)\n\n```bash\nknowledgine capture add \"<content>\" --title \"<title>\" --tags \"<tag1>,<tag2>\"\n```\n\n## Content Format\n\nStructure each capture as three parts:\n\n1. **Problem / Context** \u2014 What situation triggered this learning?\n2. **Solution / Decision** \u2014 What was done and how?\n3. **Rationale / Notes** \u2014 Why this approach? What alternatives were considered?\n\nExample:\n```\n**Problem**: TypeScript threw \"Type 'unknown' is not assignable to type 'User'\" when\nparsing API response.\n\n**Solution**: Added a type guard function isUser(val: unknown): val is User that checks\nfor required fields before narrowing the type.\n\n**Rationale**: Using 'as User' cast was unsafe because the API response structure could\nchange. The type guard provides runtime validation and compile-time safety.\n```\n\n## Step-by-Step Instructions\n\n1. **Identify the trigger** \u2014 Which of the 6 capture events occurred?\n2. **Draft the content** \u2014 Write problem + solution + rationale in plain prose\n3. **Choose a title** \u2014 Concise, searchable (start with verb or noun phrase)\n4. **Select 2\u20135 tags** \u2014 Use the standard taxonomy (see capture-guide.md)\n5. **Call capture_knowledge** \u2014 Pass content, title, tags, and optional source\n6. **Verify** \u2014 Confirm the tool returned a success response\n\n## Best Practices\n\n- Capture immediately after the event while details are fresh\n- Write for a future reader who has no context from this session\n- Prefer one focused capture per insight over large omnibus entries\n- Include error messages verbatim \u2014 they are the most effective search terms\n- Tag precisely: broad tags like \"misc\" reduce discoverability\n\n## Reference Files\n\n- See `capture-guide.md` for detailed guidance on each trigger type with examples\n- See `tag-taxonomy.md` for the standard tag categories\n- See `format-examples.md` for 3\u20135 concrete capture examples\n";
+//# sourceMappingURL=skill-md.d.ts.map

package/dist/templates/skills/knowledgine-capture/skill-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-md.d.ts","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-capture/skill-md.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,m2HA+FpB,CAAC"}

package/dist/templates/skills/knowledgine-capture/skill-md.js

@@ -0,0 +1,97 @@
+export const SKILL_MD = `---
+name: knowledgine-capture
+description: >
+  Record knowledge to the local knowledge base after solving problems, making design
+  decisions, or discovering reusable patterns. Invoke whenever you have just fixed a bug,
+  made an architectural choice, found a reusable pattern, learned something from external
+  sources, or completed a refactoring. Capturing while context is fresh prevents knowledge
+  loss across sessions.
+---
+# knowledgine-capture
+
+## Purpose
+
+Persist valuable learnings from the current session into the local knowledge base so they
+are available for future sessions and team members. The knowledge base is only as useful
+as what is recorded into it.
+
+## When to Use
+
+Capture knowledge when **any** of the following events occur in the session:
+
+1. **Bug fix** — You identified a root cause and applied a solution
+2. **Design decision** — You chose one approach over alternatives with reasoning
+3. **Pattern discovery** — You found a reusable pattern worth applying elsewhere
+4. **Troubleshooting** — You worked through a non-obvious diagnosis process
+5. **External knowledge** — You applied insights from documentation, articles, or Stack Overflow
+6. **Refactoring** — You improved existing code with a clear before/after
+
+## When NOT to Use
+
+- Trivial edits (typo fixes, formatting changes) that contain no transferable insight
+- Highly project-specific one-off changes with no reuse value
+- Duplicate entries: first search with \`search_knowledge\` to check if the knowledge already exists
+
+## How to Capture (MCP Tool)
+
+Use the \`capture_knowledge\` MCP tool:
+
+\`\`\`
+capture_knowledge(
+  content: string,   // Full explanation: problem + solution + context
+  title: string,     // Short descriptive title (max ~80 chars)
+  tags: string[],    // 2–5 tags from the standard taxonomy
+  source?: string    // Optional: URL, filename, or reference source
+)
+\`\`\`
+
+## How to Capture (CLI Alternative)
+
+\`\`\`bash
+knowledgine capture add "<content>" --title "<title>" --tags "<tag1>,<tag2>"
+\`\`\`
+
+## Content Format
+
+Structure each capture as three parts:
+
+1. **Problem / Context** — What situation triggered this learning?
+2. **Solution / Decision** — What was done and how?
+3. **Rationale / Notes** — Why this approach? What alternatives were considered?
+
+Example:
+\`\`\`
+**Problem**: TypeScript threw "Type 'unknown' is not assignable to type 'User'" when
+parsing API response.
+
+**Solution**: Added a type guard function isUser(val: unknown): val is User that checks
+for required fields before narrowing the type.
+
+**Rationale**: Using 'as User' cast was unsafe because the API response structure could
+change. The type guard provides runtime validation and compile-time safety.
+\`\`\`
+
+## Step-by-Step Instructions
+
+1. **Identify the trigger** — Which of the 6 capture events occurred?
+2. **Draft the content** — Write problem + solution + rationale in plain prose
+3. **Choose a title** — Concise, searchable (start with verb or noun phrase)
+4. **Select 2–5 tags** — Use the standard taxonomy (see capture-guide.md)
+5. **Call capture_knowledge** — Pass content, title, tags, and optional source
+6. **Verify** — Confirm the tool returned a success response
+
+## Best Practices
+
+- Capture immediately after the event while details are fresh
+- Write for a future reader who has no context from this session
+- Prefer one focused capture per insight over large omnibus entries
+- Include error messages verbatim — they are the most effective search terms
+- Tag precisely: broad tags like "misc" reduce discoverability
+
+## Reference Files
+
+- See \`capture-guide.md\` for detailed guidance on each trigger type with examples
+- See \`tag-taxonomy.md\` for the standard tag categories
+- See \`format-examples.md\` for 3–5 concrete capture examples
+`;
+//# sourceMappingURL=skill-md.js.map

package/dist/templates/skills/knowledgine-capture/skill-md.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-md.js","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-capture/skill-md.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+FvB,CAAC"}

package/dist/templates/skills/knowledgine-debrief/references.d.ts

@@ -0,0 +1,2 @@
+export declare const REFERENCES: Record<string, string>;
+//# sourceMappingURL=references.d.ts.map

package/dist/templates/skills/knowledgine-debrief/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-debrief/references.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2I7C,CAAC"}