@knowledgine/cli 0.5.0 → 0.6.0

package/dist/templates/skills/knowledgine-search/skill-md.ja.js

@@ -0,0 +1,175 @@
+export const SKILL_MD = `---
+name: knowledgine-search
+version: "1.0.0"
+lang: ja
+description: >
+  過去の解決策、設計上の決定、パターンをローカルナレッジベースから検索します。
+  エラーに直面したとき、慣れないコードに取り組むとき、セッションを開始するとき、
+  新しいファイルを開くとき、実装アプローチを検討するときに呼び出します。
+  クエリ直接検索・コンテキストベースのサジェスト・グラフによる関連ノート探索の
+  3つのモードをサポートします。
+---
+# knowledgine-search
+
+## 目的
+
+問題をゼロから解決しようとする前に、蓄積されたプロジェクトの知識を検索します。
+ナレッジベースには、過去のバグ修正、設計上の決定、トラブルシューティングの記録、
+そして全セッションを通じて収集されたパターンが含まれています。このスキルは
+クエリ直接検索とコンテキストベースの探索を単一のワークフローに統合し、
+重複作業を防いで関連するコンテキストを先回りして提示します。
+
+## 使用するタイミング
+
+- **エラーや例外が発生したとき** — 正確なエラーメッセージやキーワードを検索する
+- **慣れないコード領域に取り組むとき** — コンポーネントやモジュールに関するコンテキストを検索する
+- **実装の選択をするとき** — 同じトピックに関する過去の決定を検索する
+- **ライブラリやアプローチを検討するとき** — 既知の落とし穴や先行事例を検索する
+- **セッションを開始するとき** — 作業する領域に関するコンテキストを取得する
+- **新しいファイルを開くとき** — そのコンポーネントに関する過去の知識を発見する
+- **機能の実装を始めるとき** — 関連するパターンや過去の決定を見つける
+- **ファイルの作業を開始するとき** — そのファイルパスに関連するノートを検索する
+
+## 使用しないタイミング
+
+- 曖昧さのない純粋に機械的なタスク（変数のリネーム、フォーマットなど）
+- このセッション内ですでに検索して関連する結果が見つからなかったとき
+- 同じファイルに対してコンテキストベースの検索をすでに実行済みのとき
+- すべての操作で検索を呼び出すことは避ける — 判断して使用する
+
+## 検索アプローチ
+
+### アプローチ 1: クエリ検索
+
+エラーメッセージ、関数名、または既知のトピックなど、具体的な語句がある場合。
+
+特定の語句で \`search_knowledge\` を使用します。完全一致には \`keyword\` モードから始め、
+正確な表現が不確かな場合は \`semantic\` または \`hybrid\` に切り替えます。
+
+### アプローチ 2: コンテキストベースの検索
+
+特定のクエリなしに、ファイルやタスクの作業を開始する場合。
+
+現在のファイルパス、コンポーネント名、タスクの説明、またはエラーメッセージから
+シグナルを抽出します。2〜3個のシグナルを組み合わせてクエリを作成し、
+最良の結果を得るには \`hybrid\` モードを使用します。コンテキストシグナルの
+抽出方法については \`search-strategy.md\` を参照してください。
+
+### アプローチ 3: 関連ノートの探索
+
+関連するノートを見つけて、ナレッジグラフ内の接続されたノートを発見したい場合。
+
+関連する結果の \`noteId\`（数値として）または現在の \`filePath\` を使って
+\`find_related\` を呼び出します。これはナレッジグラフを走査して、エンティティの
+関係性、問題と解決策のペア、ファイルの関連性によってリンクされたノートを
+提示します。
+
+## 検索モードの選択
+
+| 状況 | モード |
+|------|--------|
+| 正確なエラーメッセージがある | \`keyword\` |
+| 特定の関数名や変数名を覚えている | \`keyword\` |
+| 概念はわかるが正確な表現が不確か | \`semantic\` |
+| コンテキストシグナル（ファイル、タスク、機能）から作業を開始する | \`hybrid\` |
+| トピックの一般的な探索 | \`hybrid\` |
+| 埋め込みが利用できない（FTS5のみの構成） | \`keyword\`（唯一の選択肢） |
+
+## 検索方法 (MCP ツール)
+
+### search_knowledge
+
+\`\`\`
+search_knowledge(
+  query: string,              // 検索クエリ
+  mode?: "keyword"            // "keyword" | "semantic" | "hybrid"
+       | "semantic"           //   keyword:  FTS5 による完全一致テキスト検索（デフォルト）
+       | "hybrid",            //   semantic: 意味ベース、埋め込みが必要
+                              //   hybrid:   両者を組み合わせ
+  limit?: number,             // 最大結果数（デフォルト: 20）
+  agentic?: boolean,          // 廃止済みノートを含む（デフォルト: false）
+  includeDeprecated?: boolean // 廃止済みノートを含む（デフォルト: false）
+)
+\`\`\`
+
+### find_related
+
+\`\`\`
+find_related(
+  noteId?: number,    // ノートの ID — 文字列ではなく数値（整数）であること
+  filePath?: string,  // 関連ノートを検索するファイルパス
+  limit?: number,     // 最大結果数（デフォルト: 5）
+  maxHops?: number    // グラフの走査深度（デフォルト: 1、最大: 3）
+)
+\`\`\`
+
+\`noteId\` または \`filePath\` のいずれか一方を指定してください。\`noteId\` の値は
+\`search_knowledge\` の結果から取得します — 数値の \`id\` フィールドをそのまま使用します。
+
+## 検索方法 (CLI の代替手段)
+
+\`\`\`bash
+knowledgine search "<query>"                     # キーワード検索
+knowledgine search "<query>" --mode semantic     # セマンティック検索
+knowledgine search "<query>" --mode hybrid       # ハイブリッド検索
+knowledgine suggest --file src/commands/setup.ts  # ファイルパスによるコンテキストベース検索（suggest コマンド）
+\`\`\`
+
+## 手順
+
+1. **アプローチを選択** — 特定のクエリがある場合（アプローチ 1）か、ファイルパスや
+   タスクの説明などのコンテキストから始める場合（アプローチ 2）か？
+
+2. **クエリを作成**
+   - アプローチ 1: エラーメッセージ、関数名、または既知のトピックをそのまま使用
+   - アプローチ 2: ファイルパス、コンポーネント名、タスク、またはエラーからシグナルを
+     抽出し、2〜3個のシグナルを組み合わせてクエリを作成（\`search-strategy.md\` 参照）
+
+3. **モードを選択**
+   - 正確な語句 → \`keyword\`
+   - コンテキストシグナルや概念的な検索 → \`hybrid\`
+   - 概念はわかるが表現が不確か → \`semantic\`
+
+4. **search_knowledge を呼び出す** — クエリ、モード、上限を指定（5〜10 件で通常十分;
+   デフォルトは 20）
+
+5. **結果を評価** — 返されたノートの関連性を読んで確認し、高度に関連する結果の
+   ID をメモする
+
+6. **関連ノートを走査（任意）** — 結果が高度に関連している場合、その数値 \`noteId\` または
+   現在の \`filePath\` を使って \`find_related\` を呼び出し、ナレッジグラフ経由で
+   接続されたノートを発見する
+
+7. **発見内容を適用** — 関連する過去の解決策や決定を、作業に活かす
+
+8. **新しい知識を記録** — 新しい解決策を発見した場合、knowledgine-capture を使って保存する
+
+## ベストプラクティス
+
+- 解決策を提案する前に検索する（後ではなく）
+- 実際のエラーメッセージテキストをクエリとして使用する — 最もターゲットを絞った検索ができる
+- 最初の検索で結果が得られない場合は、複数のクエリを試みる
+- セッション開始時に、主な作業領域に対してコンテキストベースの検索（アプローチ 2）を実行し、
+  その後、特定の問題が発生したら対象を絞ったクエリ（アプローチ 1）を使用する
+- \`bug-fix\` または \`troubleshooting\` タグが付いたノートを優先する — 警告が含まれている
+- \`design-decision\` タグのノートは変更を加える前に特に価値がある
+- \`find_related\` の \`noteId\` パラメータは数値 — 文字列ではなく、検索結果の整数 id フィールドを渡す
+
+## エッジケース
+
+- **ナレッジベースが空の場合** — \`search_knowledge\` がまったく結果を返さない場合、
+  ナレッジベースはまだ入力されていない可能性があります。コードベースをインデックス化するために
+  knowledgine-ingest を使用するか、knowledgine-capture で知識の記録を開始することを提案してください。
+- **セマンティックまたはハイブリッドモードがエラーを返す場合** — 埋め込みが設定されていない可能性があります。
+  SQLite FTS5 のみに依存して常に動作する \`keyword\` モードにフォールバックしてください。
+- **find_related が noteId でエラーを返す場合** — 値が \`search_knowledge\` の結果から
+  得た正の整数であることを確認し、文字列表現でないことを確かめてください。
+
+## 参照ファイル
+
+- モード選択、コンテキストシグナルの抽出、ワークフローパターン、結果の解釈については
+  \`search-strategy.md\` を参照
+- クエリの作成テンプレート、フォールバック戦略、上限のガイダンスについては
+  \`query-tips.md\` を参照
+`;
+//# sourceMappingURL=skill-md.ja.js.map

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

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

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

@@ -0,0 +1,174 @@
+export const SKILL_MD = `---
+name: knowledgine-search
+version: "1.0.0"
+lang: en
+description: >
+  Search the local knowledge base for past solutions, design decisions, and patterns.
+  Invoke when facing an error, approaching unfamiliar code, starting a session, opening
+  a new file, or considering implementation approaches. Supports three modes: direct
+  query search, context-based suggestions, and graph-based related note discovery.
+---
+# knowledgine-search
+
+## Purpose
+
+Search accumulated project knowledge before solving problems from scratch. The knowledge
+base contains past bug fixes, design decisions, troubleshooting records, and patterns
+gathered across all previous sessions. This skill unifies direct query search and
+context-based discovery into a single workflow, preventing duplicate work and surfacing
+relevant context proactively.
+
+## When to Use
+
+- **Error or exception encountered** — Search for the exact error message or key terms
+- **Unfamiliar code area** — Search for context about the component or module
+- **Implementation choice** — Search for past decisions on the same topic
+- **Considering a library or approach** — Search for known gotchas or prior art
+- **Starting a session** — Get context about the area you will work in
+- **Opening a new file** — Discover past knowledge about that component
+- **Beginning a feature** — Find related patterns and past decisions
+- **Starting work on a file** — Search for related notes about that file path
+
+## When NOT to Use
+
+- Purely mechanical tasks with no ambiguity (renaming a variable, formatting)
+- When you have already searched and found no relevant results within this session
+- After already running context-based search for the same file in the same session
+- Do not call search on every single action — use judgment
+
+## Search Approaches
+
+### Approach 1: Query Search
+
+You have specific terms — an error message, a function name, or a known topic.
+
+Use \`search_knowledge\` with the specific terms. Start with \`keyword\` mode for exact
+matches; switch to \`semantic\` or \`hybrid\` when the exact wording is uncertain.
+
+### Approach 2: Context-Based Search
+
+You are starting work on a file or task without a specific query in mind.
+
+Extract signals from the current file path, component name, task description, or error
+message. Combine 2–3 signals into a query and use \`hybrid\` mode for best results. See
+\`search-strategy.md\` for how to extract context signals.
+
+### Approach 3: Related Note Discovery
+
+You have found a relevant note and want to discover connected notes in the knowledge graph.
+
+Call \`find_related\` with the \`noteId\` (as a number) from the relevant result, or with
+the current \`filePath\`. This traverses the knowledge graph to surface notes linked by
+entity relationships, problem-solution pairs, and file associations.
+
+## Choosing Search Mode
+
+| Situation | Mode |
+|-----------|------|
+| You have an exact error message | \`keyword\` |
+| You remember specific function or variable names | \`keyword\` |
+| You know the concept but not the exact wording | \`semantic\` |
+| Starting work with context signals (file, task, feature) | \`hybrid\` |
+| General exploration of a topic | \`hybrid\` |
+| Embeddings not available (FTS5-only setup) | \`keyword\` (only option) |
+
+## How to Search (MCP Tools)
+
+### search_knowledge
+
+\`\`\`
+search_knowledge(
+  query: string,              // Search query
+  mode?: "keyword"            // "keyword" | "semantic" | "hybrid"
+       | "semantic"           //   keyword:  exact text match via FTS5 (default)
+       | "hybrid",            //   semantic: meaning-based, requires embeddings
+                              //   hybrid:   combines both
+  limit?: number,             // Max results (default: 20)
+  agentic?: boolean,          // Include deprecated notes (default: false)
+  includeDeprecated?: boolean // Include deprecated notes (default: false)
+)
+\`\`\`
+
+### find_related
+
+\`\`\`
+find_related(
+  noteId?: number,    // ID of a note — must be a NUMBER (integer), not a string
+  filePath?: string,  // File path to find related notes for
+  limit?: number,     // Max results (default: 5)
+  maxHops?: number    // Graph traversal depth (default: 1, max: 3)
+)
+\`\`\`
+
+Provide at least one of \`noteId\` or \`filePath\`. \`noteId\` values come from
+\`search_knowledge\` results — use the numeric \`id\` field directly.
+
+## How to Search (CLI Alternative)
+
+\`\`\`bash
+knowledgine search "<query>"                     # keyword search
+knowledgine search "<query>" --mode semantic     # semantic search
+knowledgine search "<query>" --mode hybrid       # hybrid search
+knowledgine suggest --file src/commands/setup.ts  # context-based by file path (suggest command)
+\`\`\`
+
+## Step-by-Step Instructions
+
+1. **Choose your approach** — Do you have a specific query (Approach 1), or are you
+   starting from context like a file path or task description (Approach 2)?
+
+2. **Extract your query**
+   - For Approach 1: Use the error message, function name, or known topic directly
+   - For Approach 2: Extract signals from file path, component name, task, or error;
+     combine 2–3 signals into a query (see \`search-strategy.md\`)
+
+3. **Choose the mode**
+   - Exact terms → \`keyword\`
+   - Context signals or conceptual search → \`hybrid\`
+   - Known concept, uncertain wording → \`semantic\`
+
+4. **Call search_knowledge** — Pass query, mode, and limit (5–10 is usually sufficient;
+   default is 20)
+
+5. **Evaluate results** — Read the returned notes for relevance; note any IDs of
+   highly relevant results
+
+6. **Traverse related notes (optional)** — If a result looks highly relevant, call
+   \`find_related\` with its numeric \`noteId\` or the current \`filePath\` to discover
+   connected notes via the knowledge graph
+
+7. **Apply findings** — Use relevant past solutions or decisions to inform your work
+
+8. **Capture if new** — If you discover a new solution, use knowledgine-capture to
+   save it
+
+## Best Practices
+
+- Search before proposing a solution, not after
+- Use the actual error message text as a query — it is the most targeted search
+- Try multiple queries if the first returns no results
+- At session start, run a context-based search (Approach 2) for the primary work area,
+  then use targeted queries (Approach 1) as specific issues arise
+- Prioritize notes tagged with \`bug-fix\` or \`troubleshooting\` — they contain warnings
+- Notes tagged \`design-decision\` are especially valuable before making changes
+- The \`noteId\` parameter of \`find_related\` is a number — pass the integer id field
+  from search results, not a string
+
+## Edge Cases
+
+- **Knowledge base is empty** — If \`search_knowledge\` returns no results at all,
+  the knowledge base may not have been populated yet. Suggest using knowledgine-ingest
+  to index the codebase or knowledgine-capture to start recording knowledge.
+- **Semantic or hybrid mode returns an error** — Embeddings may not be configured.
+  Fall back to \`keyword\` mode, which relies only on SQLite FTS5 and always works.
+- **find_related returns an error for a noteId** — Confirm the value is a positive
+  integer from a \`search_knowledge\` result, not a string representation.
+
+## Reference Files
+
+- See \`search-strategy.md\` for mode selection, context signal extraction, workflow
+  patterns, and result interpretation
+- See \`query-tips.md\` for query formulation templates, fallback strategies, and
+  limit guidance
+`;
+//# sourceMappingURL=skill-md.js.map

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

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

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

@@ -0,0 +1,4 @@
+export declare const SUPPORTED_LOCALES: readonly ["en", "ja"];
+export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
+export declare const DEFAULT_LOCALE: SupportedLocale;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/templates/skills/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,uBAAwB,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AACjE,eAAO,MAAM,cAAc,EAAE,eAAsB,CAAC"}

package/dist/templates/skills/types.js

@@ -0,0 +1,3 @@
+export const SUPPORTED_LOCALES = ["en", "ja"];
+export const DEFAULT_LOCALE = "en";
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/templates/skills/types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU,CAAC;AAEvD,MAAM,CAAC,MAAM,cAAc,GAAoB,IAAI,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowledgine/cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,9 +25,9 @@
     "log-symbols": "^7.0.1",
     "ora": "^9.3.0",
     "smol-toml": "^1.6.1",
-    "@knowledgine/core": "0.5.0",
-    "@knowledgine/ingest": "0.5.0",
-    "@knowledgine/mcp-server": "0.5.0"
+    "@knowledgine/mcp-server": "0.6.0",
+    "@knowledgine/core": "0.6.0",
+    "@knowledgine/ingest": "0.6.0"
   },
   "files": [
     "dist",

package/dist/lib/entity-extractor.d.ts

@@ -1,17 +0,0 @@
-import { KnowledgeRepository, GraphRepository } from "@knowledgine/core";
-export interface PostIngestSummary {
-    totalNotes: number;
-    processedNotes: number;
-    totalEntities: number;
-    totalRelations: number;
-    totalPatterns: number;
-    errors: number;
-}
-/**
- * 全ノートに対してパターン抽出、エンティティ抽出、関係推論をバッチ実行する。
- * init コマンドから ingest パイプライン経由でノートが保存された後に呼ばれる。
- *
- * @deprecated 新規コードは IncrementalExtractor を直接使用してください
- */
-export declare function postIngestProcessing(repository: KnowledgeRepository, graphRepository: GraphRepository, onProgress?: (current: number, total: number) => void): Promise<PostIngestSummary>;
-//# sourceMappingURL=entity-extractor.d.ts.map

package/dist/lib/entity-extractor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entity-extractor.d.ts","sourceRoot":"","sources":["../../src/lib/entity-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAwB,MAAM,mBAAmB,CAAC;AAE/F,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,mBAAmB,EAC/B,eAAe,EAAE,eAAe,EAChC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACpD,OAAO,CAAC,iBAAiB,CAAC,CAe5B"}

package/dist/lib/entity-extractor.js

@@ -1,22 +0,0 @@
-import { KnowledgeRepository, GraphRepository, IncrementalExtractor } from "@knowledgine/core";
-/**
- * 全ノートに対してパターン抽出、エンティティ抽出、関係推論をバッチ実行する。
- * init コマンドから ingest パイプライン経由でノートが保存された後に呼ばれる。
- *
- * @deprecated 新規コードは IncrementalExtractor を直接使用してください
- */
-export async function postIngestProcessing(repository, graphRepository, onProgress) {
-    const allNoteIds = repository.getAllNoteIds();
-    const totalNotes = allNoteIds.length;
-    const incrementalExtractor = new IncrementalExtractor(repository, graphRepository);
-    const summary = await incrementalExtractor.process(allNoteIds, onProgress);
-    return {
-        totalNotes,
-        processedNotes: summary.processedNotes,
-        totalEntities: summary.totalEntities,
-        totalRelations: summary.totalRelations,
-        totalPatterns: summary.totalPatterns,
-        errors: summary.errors,
-    };
-}
-//# sourceMappingURL=entity-extractor.js.map

package/dist/lib/entity-extractor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"entity-extractor.js","sourceRoot":"","sources":["../../src/lib/entity-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAW/F;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,UAA+B,EAC/B,eAAgC,EAChC,UAAqD;IAErD,MAAM,UAAU,GAAG,UAAU,CAAC,aAAa,EAAE,CAAC;IAC9C,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC;IAErC,MAAM,oBAAoB,GAAG,IAAI,oBAAoB,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;IACnF,MAAM,OAAO,GAAG,MAAM,oBAAoB,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAE3E,OAAO;QACL,UAAU;QACV,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,MAAM,EAAE,OAAO,CAAC,MAAM;KACvB,CAAC;AACJ,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare const SKILL_MD = "---\nname: knowledgine-explain\ndescription: >\n  Explore entities, knowledge graph connections, and design history for unfamiliar\n  components. Invoke when exploring code you did not write, tracing the history of a\n  design decision, or understanding how a named entity (technology, library, project,\n  person) relates to other parts of the knowledge base.\n---\n# knowledgine-explain\n\n## Purpose\n\nTrace the knowledge graph to understand why things are the way they are. Explain uses\nentity search and graph traversal to surface the full context around a component or\nconcept \u2014 not just what exists, but how it connects to other parts of the system and\nwhat decisions shaped it.\n\n## When to Use\n\n- **Exploring unfamiliar code** \u2014 Who wrote what and why? What decisions shaped this?\n- **Understanding design rationale** \u2014 What alternatives were considered?\n- **Tracing knowledge provenance** \u2014 Where did this pattern or approach come from?\n- **Auditing a technology choice** \u2014 Why is this library used here?\n- **Understanding relationships** \u2014 How do components A and B relate?\n\n## When NOT to Use\n\n- When you just need to find a specific past solution (use knowledgine-recall instead)\n- When the entity does not exist in the knowledge base yet\n- For trivial well-known concepts with no project-specific context\n\n## How to Explain (MCP Tools)\n\n### Step 1: Search for entities\n\n```\nsearch_entities(\n  query: string,   // Entity name, technology, concept, or person\n  limit?: number   // Max results (default 10)\n)\n```\n\n### Step 2: Explore entity graph\n\n```\nget_entity_graph(\n  entityId?: string,    // ID from search_entities result\n  entityName?: string   // Or search by name directly\n)\n```\n\n### Step 3: Find related notes\n\n```\nfind_related(\n  noteId?: string,    // A relevant note ID found in earlier steps\n  filePath?: string,  // Or a relevant file path\n  limit?: number,\n  maxHops?: number    // 1\u20133, default 2\n)\n```\n\n## How to Explain (CLI Alternative)\n\n```bash\nknowledgine explain \"<entity name or concept>\"\n```\n\n## Step-by-Step Instructions\n\n1. **Identify the subject** \u2014 What entity, component, or concept do you want to understand?\n2. **Search for the entity** \u2014 Call `search_entities` with the subject name\n3. **Inspect the entity graph** \u2014 Call `get_entity_graph` with the entity ID\n4. **Traverse related notes** \u2014 Call `find_related` for notes that mention this entity\n5. **Synthesize findings** \u2014 Summarize what you learned about the entity's history and connections\n\n## Best Practices\n\n- Start with `search_entities` to discover the exact entity name as stored in the knowledge base\n- Use `get_entity_graph` to map the neighborhood before diving into individual notes\n- Increase `maxHops` gradually \u2014 start at 1, go to 2 or 3 if the immediate neighborhood is sparse\n- Look specifically for notes tagged `design-decision` \u2014 they explain the \"why\"\n\n## Reference Files\n\n- See `entity-types.md` for the entity taxonomy used in knowledgine\n- See `graph-navigation.md` for how to traverse the knowledge graph effectively\n";
-//# sourceMappingURL=skill-md.d.ts.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"references.js","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-recall/references.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAA2B;IAChD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8GvB;IAEC,eAAe,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FlB;CACA,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare const SKILL_MD = "---\nname: knowledgine-recall\ndescription: >\n  Search the local knowledge base for past solutions, design decisions, and patterns\n  before starting work. Invoke when facing an error or exception, when approaching an\n  unfamiliar area of the codebase, or when considering implementation approaches.\n  Prevents re-solving already-solved problems and surfaces relevant context proactively.\n---\n# knowledgine-recall\n\n## Purpose\n\nSearch accumulated project knowledge before solving problems from scratch. The knowledge\nbase contains past bug fixes, design decisions, troubleshooting records, and patterns\ngathered across all previous sessions. Searching first avoids duplicate work and surfaces\nwarnings about known pitfalls.\n\n## When to Use\n\n- **Error or exception encountered** \u2014 Search for the exact error message or key terms\n- **Unfamiliar code area** \u2014 Search for context about the component or module\n- **Implementation choice** \u2014 Search for past decisions on the same topic\n- **Considering a library or approach** \u2014 Search for known gotchas or prior art\n- **Starting work on a file** \u2014 Search for related notes about that file path\n\n## When NOT to Use\n\n- Purely mechanical tasks with no ambiguity (renaming a variable, formatting)\n- When you have already searched and found no relevant results within this session\n- Do not call recall on every single action \u2014 use judgment\n\n## How to Search (MCP Tool)\n\nUse the `search_knowledge` MCP tool:\n\n```\nsearch_knowledge(\n  query: string,          // Search query \u2014 see query tips below\n  mode: \"keyword\"         // \"keyword\" | \"semantic\" | \"hybrid\"\n       | \"semantic\"       //   keyword: exact text match (fast, precise)\n       | \"hybrid\",        //   semantic: meaning-based (requires embeddings)\n                          //   hybrid:   combines both (best results)\n  limit?: number          // Max results (default 10)\n)\n```\n\n## How to Search (CLI Alternative)\n\n```bash\nknowledgine recall \"<query>\"                    # keyword search\nknowledgine recall \"<query>\" --mode semantic    # semantic search\nknowledgine recall \"<query>\" --mode hybrid      # hybrid search\n```\n\n## Choosing Search Mode\n\n| Situation | Mode |\n|-----------|------|\n| You have an exact error message | `keyword` |\n| You remember specific function or variable names | `keyword` |\n| You know the concept but not the exact wording | `semantic` |\n| General exploration of a topic | `hybrid` |\n| Embeddings not available (FTS5-only setup) | `keyword` (only option) |\n\n## Step-by-Step Instructions\n\n1. **Identify the query** \u2014 Extract the key terms from the problem (see search-strategy.md)\n2. **Choose mode** \u2014 keyword for precise terms, semantic or hybrid for concepts\n3. **Call search_knowledge** \u2014 Pass query, mode, limit (5\u201310 is usually sufficient)\n4. **Evaluate results** \u2014 Read the returned notes for relevance\n5. **Apply findings** \u2014 Use relevant past solutions or decisions to inform your work\n6. **Capture if new** \u2014 If you discover a new solution, use knowledgine-capture to save it\n\n## Best Practices\n\n- Search before proposing a solution, not after\n- Use the actual error message text as a query \u2014 it is the most targeted search\n- Try multiple queries if the first returns no results\n- Combine recall + suggest at session start for comprehensive context\n\n## Reference Files\n\n- See `search-strategy.md` for when to use keyword vs semantic vs hybrid\n- See `query-tips.md` for how to formulate effective queries\n";
-//# sourceMappingURL=skill-md.d.ts.map

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

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

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

@@ -1,86 +0,0 @@
-export const SKILL_MD = `---
-name: knowledgine-recall
-description: >
-  Search the local knowledge base for past solutions, design decisions, and patterns
-  before starting work. Invoke when facing an error or exception, when approaching an
-  unfamiliar area of the codebase, or when considering implementation approaches.
-  Prevents re-solving already-solved problems and surfaces relevant context proactively.
----
-# knowledgine-recall
-
-## Purpose
-
-Search accumulated project knowledge before solving problems from scratch. The knowledge
-base contains past bug fixes, design decisions, troubleshooting records, and patterns
-gathered across all previous sessions. Searching first avoids duplicate work and surfaces
-warnings about known pitfalls.
-
-## When to Use
-
-- **Error or exception encountered** — Search for the exact error message or key terms
-- **Unfamiliar code area** — Search for context about the component or module
-- **Implementation choice** — Search for past decisions on the same topic
-- **Considering a library or approach** — Search for known gotchas or prior art
-- **Starting work on a file** — Search for related notes about that file path
-
-## When NOT to Use
-
-- Purely mechanical tasks with no ambiguity (renaming a variable, formatting)
-- When you have already searched and found no relevant results within this session
-- Do not call recall on every single action — use judgment
-
-## How to Search (MCP Tool)
-
-Use the \`search_knowledge\` MCP tool:
-
-\`\`\`
-search_knowledge(
-  query: string,          // Search query — see query tips below
-  mode: "keyword"         // "keyword" | "semantic" | "hybrid"
-       | "semantic"       //   keyword: exact text match (fast, precise)
-       | "hybrid",        //   semantic: meaning-based (requires embeddings)
-                          //   hybrid:   combines both (best results)
-  limit?: number          // Max results (default 10)
-)
-\`\`\`
-
-## How to Search (CLI Alternative)
-
-\`\`\`bash
-knowledgine recall "<query>"                    # keyword search
-knowledgine recall "<query>" --mode semantic    # semantic search
-knowledgine recall "<query>" --mode hybrid      # hybrid search
-\`\`\`
-
-## Choosing Search Mode
-
-| Situation | Mode |
-|-----------|------|
-| You have an exact error message | \`keyword\` |
-| You remember specific function or variable names | \`keyword\` |
-| You know the concept but not the exact wording | \`semantic\` |
-| General exploration of a topic | \`hybrid\` |
-| Embeddings not available (FTS5-only setup) | \`keyword\` (only option) |
-
-## Step-by-Step Instructions
-
-1. **Identify the query** — Extract the key terms from the problem (see search-strategy.md)
-2. **Choose mode** — keyword for precise terms, semantic or hybrid for concepts
-3. **Call search_knowledge** — Pass query, mode, limit (5–10 is usually sufficient)
-4. **Evaluate results** — Read the returned notes for relevance
-5. **Apply findings** — Use relevant past solutions or decisions to inform your work
-6. **Capture if new** — If you discover a new solution, use knowledgine-capture to save it
-
-## Best Practices
-
-- Search before proposing a solution, not after
-- Use the actual error message text as a query — it is the most targeted search
-- Try multiple queries if the first returns no results
-- Combine recall + suggest at session start for comprehensive context
-
-## Reference Files
-
-- See \`search-strategy.md\` for when to use keyword vs semantic vs hybrid
-- See \`query-tips.md\` for how to formulate effective queries
-`;
-//# sourceMappingURL=skill-md.js.map

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

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