@knowledgine/cli 0.2.1 → 0.3.0

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

@@ -0,0 +1,214 @@
+export const REFERENCES = {
+    "error-types.md": `# Error Types
+
+Descriptions and examples of the three entity extraction error types.
+
+---
+
+## false_positive
+
+**Definition**: An entity was extracted that is not actually a meaningful named entity.
+The extraction system incorrectly identified a word or phrase as a significant entity.
+
+**Common causes**:
+- Common English words extracted as entity types (e.g., "Map" as technology)
+- Context-specific jargon that is not a real entity (e.g., "Result" as a concept)
+- Partial matches of entity names (e.g., "Type" extracted from "TypeScript")
+
+**Examples**:
+
+| Entity | Extracted Type | Why it's wrong |
+|--------|---------------|----------------|
+| "the" | concept | Common article, not an entity |
+| "Manager" | technology | Generic class name suffix, not a product |
+| "Error" | technology | Common programming term, not a specific tool |
+| "Result" | concept | Generic programming term, used everywhere |
+
+**When to report**:
+Report when the false entity appears frequently in search results and reduces result
+quality. A single occurrence in one obscure note may not be worth reporting.
+
+**How to report**:
+\`\`\`
+report_extraction_error(
+  entityName: "Manager",
+  errorType: "false_positive",
+  entityType: "technology",
+  details: "Generic class name suffix, not a specific technology product"
+)
+\`\`\`
+
+---
+
+## wrong_type
+
+**Definition**: A real, meaningful entity was extracted but assigned to the wrong type.
+The entity exists and is valid, but it is categorized incorrectly.
+
+**Common causes**:
+- Technologies named like people (e.g., "Rust" could be confused with a surname)
+- Concepts with technical names
+- Projects or tools that share names with common words
+
+**Examples**:
+
+| Entity | Wrong Type | Correct Type | Reason |
+|--------|-----------|--------------|--------|
+| "TypeScript" | person | technology | A programming language, not a person |
+| "Rust" | concept | technology | A programming language |
+| "knowledgine" | concept | project | The name of this project |
+| "Jest" | person | technology | A JavaScript testing framework |
+
+**When to report**:
+Report when wrong type classification causes the entity to appear in irrelevant searches
+or prevents it from appearing in the correct entity type queries.
+
+**How to report**:
+\`\`\`
+report_extraction_error(
+  entityName: "TypeScript",
+  errorType: "wrong_type",
+  entityType: "person",
+  correctType: "technology",
+  details: "TypeScript is a programming language, not a person's name"
+)
+\`\`\`
+
+---
+
+## missed_entity
+
+**Definition**: A significant entity was not extracted at all. The entity appears
+in knowledge base notes but has no entity record in the graph.
+
+**Common causes**:
+- Entity extraction confidence threshold was too high for this entity
+- Entity name was mentioned in an unusual format or context
+- Entity is new and the extractor's model was not trained on it
+- Entity appears in code blocks rather than prose
+
+**Examples**:
+- "Zod" mentioned throughout validation code but no entity extracted
+- A team member's name that appears in commit messages but not in entity graph
+- A specific error code (e.g., "SQLITE_CONSTRAINT_UNIQUE") that is referenced often
+- A library name that only appears in import statements
+
+**When to report**:
+Report when an entity is important enough that you would use \`search_entities\` or
+\`get_entity_graph\` to find it. Minor entities with low frequency may not be worth adding.
+
+**How to report**:
+\`\`\`
+report_extraction_error(
+  entityName: "Zod",
+  errorType: "missed_entity",
+  details: "Validation library used throughout packages/core for schema validation. \
+Appears in imports and error messages but no entity was extracted."
+)
+\`\`\`
+`,
+    "feedback-guide.md": `# Feedback Guide
+
+How to write effective feedback reports that lead to extraction improvements.
+
+---
+
+## What Makes Feedback Effective
+
+Good feedback:
+1. **Identifies the specific entity** — Exact name, not a description
+2. **States the correct classification** — What type it should or should not be
+3. **Explains why** — A brief rationale makes the feedback actionable
+4. **References a note** — Links to where the issue was observed (when possible)
+
+---
+
+## Workflow for Reporting Feedback
+
+### Step 1: Identify the issue
+
+Use \`search_entities\` to find the entity in question:
+\`\`\`
+search_entities(query: "TypeScript", limit: 5)
+\`\`\`
+
+Check the returned type against what you expect.
+
+### Step 2: Find a relevant note (optional but helpful)
+
+If you saw the entity misclassified in a specific note, note its ID.
+You can find note IDs in search_knowledge results.
+
+### Step 3: Report
+
+Call \`report_extraction_error\` with all available information:
+\`\`\`
+report_extraction_error(
+  entityName: "<exact name>",
+  errorType: "<false_positive|wrong_type|missed_entity>",
+  entityType: "<current type if known>",
+  correctType: "<correct type for wrong_type errors>",
+  noteId: "<note id if available>",
+  details: "<1–2 sentence explanation>"
+)
+\`\`\`
+
+### Step 4: Verify submission
+
+Confirm the tool returned a success response with a feedback ID.
+Note the ID if you want to track the feedback status later.
+
+---
+
+## Writing the Details Field
+
+The \`details\` field is the most important part of effective feedback. Include:
+
+- What the entity actually is (if not obvious from its name)
+- Why the extracted type is wrong
+- How frequently the entity appears (if it is a missed entity)
+- Any context that might help the extractor improve
+
+**Weak details**:
+\`\`\`
+details: "wrong"
+details: "this is not right"
+\`\`\`
+
+**Strong details**:
+\`\`\`
+details: "Zod is a TypeScript-first schema validation library. It appears in ~20 notes
+under packages/core/src as imports and in error messages but was not extracted. It
+should be classified as 'technology'."
+\`\`\`
+
+---
+
+## Prioritizing What to Report
+
+| Priority | Criteria |
+|----------|----------|
+| High | Entity appears in many notes; wrong type pollutes search results |
+| High | Missed entity is central to the project domain |
+| Medium | False positive appears often but does not cause significant harm |
+| Low | Single-occurrence issue with minimal impact on search quality |
+
+---
+
+## After Reporting
+
+Check feedback status and apply improvements:
+
+\`\`\`bash
+# List pending feedback
+knowledgine feedback list --status pending
+
+# View statistics on feedback quality
+knowledgine feedback stats
+\`\`\`
+
+Applied feedback updates the extraction configuration so future ingests produce
+better results. Dismissed feedback is recorded but no change is made.
+`,
+};
+//# sourceMappingURL=references.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"references.js","sourceRoot":"","sources":["../../../../src/templates/skills/knowledgine-feedback/references.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAA2B;IAChD,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GnB;IAEC,mBAAmB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGtB;CACA,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const SKILL_MD = "---\nname: knowledgine-feedback\ndescription: >\n  Report incorrect, missing, or misclassified entity extractions to improve knowledge\n  base quality. Invoke when you notice an entity that should not exist (false positive),\n  an entity assigned to the wrong type (wrong_type), or a real entity that was not\n  extracted at all (missed_entity).\n---\n# knowledgine-feedback\n\n## Purpose\n\nImprove the quality of automatic entity extraction by reporting errors. Feedback is\nstored and can be applied to update extraction rules, preventing the same errors from\nrecurring in future ingests.\n\n## When to Use\n\n- **False positive detected** \u2014 An entity was extracted that is not actually a named entity\n  (e.g., a common English word extracted as a \"technology\" entity)\n- **Wrong type detected** \u2014 An entity exists but is classified incorrectly\n  (e.g., \"TypeScript\" classified as \"person\" instead of \"technology\")\n- **Missed entity detected** \u2014 An important entity was not extracted at all\n  (e.g., a library name that appears frequently but has no entity record)\n\n## When NOT to Use\n\n- When entity extraction quality is acceptable \u2014 minor imprecision is normal\n- For subjective disagreements about entity importance (not extracting an entity\n  does not always mean it was missed \u2014 the extractor uses confidence thresholds)\n\n## How to Report (MCP Tool)\n\nUse the `report_extraction_error` MCP tool:\n\n```\nreport_extraction_error(\n  entityName: string,      // The entity name as it appears in the note\n  errorType: string,       // \"false_positive\" | \"wrong_type\" | \"missed_entity\"\n  entityType?: string,     // Current entity type (for wrong_type and false_positive)\n  correctType?: string,    // What the type should be (for wrong_type)\n  noteId?: string,         // ID of the note where the issue was observed\n  details?: string         // Additional context about the error\n)\n```\n\n## How to Report (CLI Alternative)\n\n```bash\n# Report a false positive\nknowledgine feedback report   --entity \"the\"   --type false_positive   --entity-type concept   --details \"Common English article incorrectly extracted as entity\"\n\n# Report wrong type\nknowledgine feedback report   --entity \"TypeScript\"   --type wrong_type   --entity-type person   --correct-type technology\n\n# Report missed entity\nknowledgine feedback report   --entity \"Zod\"   --type missed_entity   --details \"Validation library used throughout packages/core but not extracted\"\n```\n\n## Step-by-Step Instructions\n\n1. **Identify the error type** \u2014 Is it a false positive, wrong type, or missed entity?\n2. **Find the entity name** \u2014 Use `search_entities` to find the exact stored name if it exists\n3. **Note the note ID** \u2014 If you observed the error in a specific note, record its ID\n4. **Call report_extraction_error** \u2014 Include all applicable parameters\n5. **Verify submission** \u2014 Confirm the tool returned a success response\n\n## Managing Feedback\n\n```bash\n# View pending feedback\nknowledgine feedback list --status pending\n\n# Apply a specific feedback report (admin operation)\nknowledgine feedback apply <id>\n\n# Dismiss feedback without applying\nknowledgine feedback dismiss <id>\n\n# View feedback statistics\nknowledgine feedback stats\n```\n\n## Best Practices\n\n- Report high-frequency errors first \u2014 they have the most impact\n- Include specific details about what makes the extraction incorrect\n- Reference a note ID when possible so the error can be verified in context\n- Do not report minor cases that have no practical impact on search quality\n\n## Reference Files\n\n- See `error-types.md` for detailed descriptions and examples of each error type\n- See `feedback-guide.md` for how to write effective feedback reports\n";
+//# sourceMappingURL=skill-md.d.ts.map

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

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

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

@@ -0,0 +1,107 @@
+export const SKILL_MD = `---
+name: knowledgine-feedback
+description: >
+  Report incorrect, missing, or misclassified entity extractions to improve knowledge
+  base quality. Invoke when you notice an entity that should not exist (false positive),
+  an entity assigned to the wrong type (wrong_type), or a real entity that was not
+  extracted at all (missed_entity).
+---
+# knowledgine-feedback
+
+## Purpose
+
+Improve the quality of automatic entity extraction by reporting errors. Feedback is
+stored and can be applied to update extraction rules, preventing the same errors from
+recurring in future ingests.
+
+## When to Use
+
+- **False positive detected** — An entity was extracted that is not actually a named entity
+  (e.g., a common English word extracted as a "technology" entity)
+- **Wrong type detected** — An entity exists but is classified incorrectly
+  (e.g., "TypeScript" classified as "person" instead of "technology")
+- **Missed entity detected** — An important entity was not extracted at all
+  (e.g., a library name that appears frequently but has no entity record)
+
+## When NOT to Use
+
+- When entity extraction quality is acceptable — minor imprecision is normal
+- For subjective disagreements about entity importance (not extracting an entity
+  does not always mean it was missed — the extractor uses confidence thresholds)
+
+## How to Report (MCP Tool)
+
+Use the \`report_extraction_error\` MCP tool:
+
+\`\`\`
+report_extraction_error(
+  entityName: string,      // The entity name as it appears in the note
+  errorType: string,       // "false_positive" | "wrong_type" | "missed_entity"
+  entityType?: string,     // Current entity type (for wrong_type and false_positive)
+  correctType?: string,    // What the type should be (for wrong_type)
+  noteId?: string,         // ID of the note where the issue was observed
+  details?: string         // Additional context about the error
+)
+\`\`\`
+
+## How to Report (CLI Alternative)
+
+\`\`\`bash
+# Report a false positive
+knowledgine feedback report \
+  --entity "the" \
+  --type false_positive \
+  --entity-type concept \
+  --details "Common English article incorrectly extracted as entity"
+
+# Report wrong type
+knowledgine feedback report \
+  --entity "TypeScript" \
+  --type wrong_type \
+  --entity-type person \
+  --correct-type technology
+
+# Report missed entity
+knowledgine feedback report \
+  --entity "Zod" \
+  --type missed_entity \
+  --details "Validation library used throughout packages/core but not extracted"
+\`\`\`
+
+## Step-by-Step Instructions
+
+1. **Identify the error type** — Is it a false positive, wrong type, or missed entity?
+2. **Find the entity name** — Use \`search_entities\` to find the exact stored name if it exists
+3. **Note the note ID** — If you observed the error in a specific note, record its ID
+4. **Call report_extraction_error** — Include all applicable parameters
+5. **Verify submission** — Confirm the tool returned a success response
+
+## Managing Feedback
+
+\`\`\`bash
+# View pending feedback
+knowledgine feedback list --status pending
+
+# Apply a specific feedback report (admin operation)
+knowledgine feedback apply <id>
+
+# Dismiss feedback without applying
+knowledgine feedback dismiss <id>
+
+# View feedback statistics
+knowledgine feedback stats
+\`\`\`
+
+## Best Practices
+
+- Report high-frequency errors first — they have the most impact
+- Include specific details about what makes the extraction incorrect
+- Reference a note ID when possible so the error can be verified in context
+- Do not report minor cases that have no practical impact on search quality
+
+## Reference Files
+
+- See \`error-types.md\` for detailed descriptions and examples of each error type
+- See \`feedback-guide.md\` for how to write effective feedback reports
+`;
+//# sourceMappingURL=skill-md.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,243 @@
+export const REFERENCES = {
+    "plugin-guide.md": `# Plugin Guide
+
+Detailed documentation for each knowledgine ingest plugin.
+
+---
+
+## markdown
+
+**Plugin ID**: \`markdown\`
+**Source**: Local markdown files in the knowledge base directory
+
+The default plugin used by \`knowledgine init\`. Scans the configured root directory
+for \`.md\` files and indexes them.
+
+\`\`\`bash
+knowledgine ingest --source markdown --path ~/notes
+\`\`\`
+
+**What it captures**: Full text of markdown files, front matter metadata, headings,
+code blocks.
+
+**Incremental**: Yes. Tracks file modification times; re-ingests changed files only.
+
+---
+
+## git-history
+
+**Plugin ID**: \`git-history\`
+**Source**: Git repository commit history
+
+Extracts knowledge from Git commit messages and associated diffs. Particularly useful
+for understanding past design decisions and the evolution of specific files.
+
+\`\`\`bash
+knowledgine ingest --source git-history --path ~/project
+\`\`\`
+
+**What it captures**: Commit messages (especially conventional commit prefixes like
+\`feat:\`, \`fix:\`, \`refactor:\`), file paths changed, commit metadata.
+
+**Prerequisites**: Must be run inside a Git repository (or with \`--path\` pointing to one).
+
+**Incremental**: Yes. Tracks the last processed commit hash.
+
+**Tips**:
+- Run with \`--full\` when first setting up to get the complete history
+- Commit messages following Conventional Commits format produce higher-quality captures
+
+---
+
+## github
+
+**Plugin ID**: \`github\`
+**Source**: GitHub Pull Requests and Issues
+
+Fetches PR descriptions, issue bodies, and comments from a GitHub repository.
+Captures design discussions, bug reports, and decision rationale.
+
+\`\`\`bash
+GITHUB_TOKEN=<token> knowledgine ingest --source github --repo owner/repo --path ~/project
+\`\`\`
+
+**Prerequisites**:
+- \`GITHUB_TOKEN\` environment variable with \`repo\` scope (or \`public_repo\` for public repos)
+- \`--repo\` flag specifying the repository (format: \`owner/repo\`)
+
+**What it captures**: PR titles and bodies, issue titles and bodies, labels.
+
+**Rate limiting**: Uses authenticated requests; limit is 5000 requests/hour with a token.
+
+**Incremental**: Yes. Tracks the last fetched item number.
+
+---
+
+## obsidian
+
+**Plugin ID**: \`obsidian\`
+**Source**: Obsidian vault markdown notes
+
+Imports notes from an Obsidian vault, preserving internal links and tags.
+
+\`\`\`bash
+knowledgine ingest --source obsidian --path ~/vault
+\`\`\`
+
+**What it captures**: Note content, Obsidian tags (converted to knowledgine tags),
+wikilinks, front matter.
+
+**Prerequisites**: The Obsidian vault directory must be accessible. No special
+configuration required — Obsidian stores notes as plain markdown.
+
+**Tips**:
+- Use \`--full\` after reorganizing your vault
+- Notes with \`#private\` or \`#ignore\` tags can be excluded via plugin configuration
+
+---
+
+## claude-sessions
+
+**Plugin ID**: \`claude-sessions\`
+**Source**: Claude Code session history
+
+Imports context from past Claude Code sessions stored in the session history.
+
+\`\`\`bash
+knowledgine ingest --source claude-sessions --path ~/project
+\`\`\`
+
+**What it captures**: Session summaries, key decisions and discoveries logged during
+past Claude Code sessions.
+
+**Storage location**: Claude Code stores session history in
+\`~/.claude/projects/<project-hash>/\`.
+
+---
+
+## cursor-sessions
+
+**Plugin ID**: \`cursor-sessions\`
+**Source**: Cursor IDE session history
+
+Imports knowledge from Cursor IDE's AI conversation history.
+
+\`\`\`bash
+knowledgine ingest --source cursor-sessions --path ~/project
+\`\`\`
+
+**What it captures**: Cursor AI conversation content that includes code decisions,
+bug fixes, and architectural discussions.
+
+**Storage location**: Cursor stores session data in its SQLite workspace database.
+
+---
+
+## cicd
+
+**Plugin ID**: \`cicd\`
+**Source**: CI/CD pipeline results (GitHub Actions)
+
+Imports CI/CD pipeline outcomes, failed test results, and deployment records.
+
+\`\`\`bash
+GITHUB_TOKEN=<token> knowledgine ingest --source cicd --repo owner/repo --path ~/project
+\`\`\`
+
+**What it captures**: Workflow run summaries, failed job details, deployment events.
+
+**Prerequisites**: \`GITHUB_TOKEN\` and \`--repo\` flag (same as github plugin).
+
+**Use case**: Building knowledge about flaky tests, infrastructure issues, and
+deployment patterns from CI history.
+`,
+    "source-types.md": `# Source Types and Configuration
+
+Configuration requirements and environment variables for each ingest source.
+
+---
+
+## Configuration Summary
+
+| Source | Required Config | Optional Config |
+|--------|----------------|-----------------|
+| \`markdown\` | \`--path\` (knowledge base dir) | — |
+| \`git-history\` | \`--path\` (git repo dir) | \`--full\` to reset cursor |
+| \`github\` | \`GITHUB_TOKEN\`, \`--repo\` | \`--full\` |
+| \`obsidian\` | \`--path\` (vault dir) | \`--full\` |
+| \`claude-sessions\` | \`--path\` | — |
+| \`cursor-sessions\` | \`--path\` | — |
+| \`cicd\` | \`GITHUB_TOKEN\`, \`--repo\` | \`--full\` |
+
+---
+
+## Environment Variables
+
+### GITHUB_TOKEN
+
+Required for \`github\` and \`cicd\` plugins.
+
+\`\`\`bash
+# Set in shell
+export GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx
+
+# Or prefix the command
+GITHUB_TOKEN=ghp_xxx knowledgine ingest --source github --repo owner/repo
+\`\`\`
+
+**Required scopes**:
+- Public repos: \`public_repo\`
+- Private repos: \`repo\`
+- For CI/CD: add \`workflow\` scope
+
+**Creating a token**:
+GitHub → Settings → Developer settings → Personal access tokens → Tokens (classic)
+
+---
+
+## Cursor State Management
+
+Each plugin tracks a "cursor" — the last processed position — to enable incremental
+ingestion. You can inspect cursor state and reset it:
+
+\`\`\`bash
+# View cursor state for all plugins
+knowledgine plugins status --path ~/project
+
+# Reset cursor to force full re-ingest
+knowledgine ingest --source <plugin> --full --path ~/project
+\`\`\`
+
+---
+
+## Running Multiple Plugins
+
+\`\`\`bash
+# Run all registered plugins sequentially
+knowledgine ingest --all --path ~/project
+
+# Check which plugins are registered
+knowledgine plugins list
+\`\`\`
+
+---
+
+## Troubleshooting
+
+### "No plugin registered with ID: xxx"
+The plugin is not registered. Check the plugin ID spelling against \`knowledgine plugins list\`.
+
+### "GITHUB_TOKEN not set"
+Set the \`GITHUB_TOKEN\` environment variable before running the github or cicd plugin.
+
+### "Repository not found"
+Verify the \`--repo\` flag uses \`owner/repo\` format and that your token has access to the repo.
+
+### Ingest produced 0 notes
+- Confirm the \`--path\` points to the correct directory
+- For git-history: ensure the path contains a .git directory
+- For obsidian: ensure the path contains .md files
+- Try \`--full\` to reset the cursor and reprocess all content
+`,
+};
+//# sourceMappingURL=references.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const SKILL_MD = "---\nname: knowledgine-ingest\ndescription: >\n  Import knowledge from external sources into the local knowledge base. Invoke when\n  the user wants to import from Git commit history, GitHub PRs and issues, Obsidian\n  vaults, Claude or Cursor session histories, or CI/CD pipelines. Each source requires\n  a specific plugin and configuration.\n---\n# knowledgine-ingest\n\n## Purpose\n\nPopulate the knowledge base from external knowledge repositories \u2014 version control\nhistory, issue trackers, personal note systems, AI session logs \u2014 without manual\ncapture. Ingestion enriches the knowledge base with historical context that predates\nthe current session.\n\n## When to Use\n\n- **Onboarding to a codebase** \u2014 Ingest Git history to capture past decisions\n- **Integrating GitHub knowledge** \u2014 Import PRs and issues for context\n- **Importing Obsidian notes** \u2014 Bring personal or team notes into the knowledge base\n- **Capturing AI session history** \u2014 Import Claude or Cursor session logs\n- **Building CI knowledge** \u2014 Import CI/CD pipeline outcomes and patterns\n- **User explicitly requests import** \u2014 \"Load my notes from Obsidian\"\n\n## When NOT to Use\n\n- When the source has already been fully ingested in this session (check cursor state)\n- When the user has not configured the required credentials (e.g., GITHUB_TOKEN)\n\n## How to Ingest (CLI)\n\n```bash\n# Run a specific plugin\nknowledgine ingest --source <plugin-id> --path <knowledge-base-path>\n\n# Run all registered plugins\nknowledgine ingest --all --path <knowledge-base-path>\n\n# Force full re-ingest (ignore stored cursor)\nknowledgine ingest --source <plugin-id> --full --path <knowledge-base-path>\n\n# GitHub-specific (requires GITHUB_TOKEN env var)\nknowledgine ingest --source github --repo owner/repo --path <path>\n```\n\n## Available Source Plugins\n\n| Plugin ID | Source | Notes |\n|-----------|--------|-------|\n| `markdown` | Local markdown files | Default; used by `knowledgine init` |\n| `git-history` | Git commit messages and diffs | Extracts decisions from commit history |\n| `github` | GitHub PRs and issues | Requires `GITHUB_TOKEN` env var |\n| `obsidian` | Obsidian vault notes | Reads from configured vault path |\n| `claude-sessions` | Claude Code session logs | Imports past AI session context |\n| `cursor-sessions` | Cursor IDE session history | Imports Cursor session context |\n| `cicd` | CI/CD pipeline results | GitHub Actions, build outcomes |\n\n## Step-by-Step Instructions\n\n1. **Identify the source** \u2014 Which external system contains the knowledge to import?\n2. **Check prerequisites** \u2014 Does the plugin need credentials or configuration? (see plugin-guide.md)\n3. **Run the ingest command** \u2014 Use the appropriate plugin ID and options\n4. **Verify results** \u2014 Run `knowledgine status` or search to confirm notes were imported\n5. **Re-ingest if needed** \u2014 Use `--full` flag to re-process already-seen content\n\n## Best Practices\n\n- Run `git-history` ingest when starting work on a new repository\n- Set `GITHUB_TOKEN` before ingesting GitHub content to avoid rate limiting\n- Use `--full` flag after changing ingest configuration\n- Check `knowledgine plugins status` to see the last ingest cursor for each plugin\n\n## Reference Files\n\n- See `plugin-guide.md` for detailed documentation on each plugin\n- See `source-types.md` for configuration requirements for each source type\n";
+//# sourceMappingURL=skill-md.d.ts.map

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

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