@getlore/cli 0.2.0

package/dist/tui/markdown.js

@@ -0,0 +1,223 @@
+/**
+ * Terminal markdown renderer
+ *
+ * Converts markdown to styled terminal output using ANSI codes.
+ * Designed for blessed terminals.
+ */
+import { colors } from '../cli/colors.js';
+/**
+ * Render markdown to terminal-friendly styled text
+ */
+export function renderMarkdown(text, width = 80) {
+    const lines = text.split('\n');
+    const result = [];
+    let inCodeBlock = false;
+    let codeBlockLang = '';
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        // Code blocks
+        if (line.startsWith('```')) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockLang = line.slice(3).trim();
+                result.push(`${colors.dim}┌${'─'.repeat(Math.min(width - 2, 40))}${colors.reset}`);
+                continue;
+            }
+            else {
+                inCodeBlock = false;
+                codeBlockLang = '';
+                result.push(`${colors.dim}└${'─'.repeat(Math.min(width - 2, 40))}${colors.reset}`);
+                continue;
+            }
+        }
+        if (inCodeBlock) {
+            result.push(`${colors.dim}│${colors.reset} ${colors.yellow}${line}${colors.reset}`);
+            continue;
+        }
+        // Headers
+        if (line.startsWith('######')) {
+            result.push(`${colors.bold}${colors.cyan}${line.slice(7).trim()}${colors.reset}`);
+            continue;
+        }
+        if (line.startsWith('#####')) {
+            result.push(`${colors.bold}${colors.cyan}${line.slice(6).trim()}${colors.reset}`);
+            continue;
+        }
+        if (line.startsWith('####')) {
+            result.push(`${colors.bold}${colors.cyan}${line.slice(5).trim()}${colors.reset}`);
+            continue;
+        }
+        if (line.startsWith('###')) {
+            result.push(`${colors.bold}${colors.cyan}${line.slice(4).trim()}${colors.reset}`);
+            continue;
+        }
+        if (line.startsWith('##')) {
+            result.push('');
+            result.push(`${colors.bold}${colors.blue}${line.slice(3).trim()}${colors.reset}`);
+            continue;
+        }
+        if (line.startsWith('#')) {
+            result.push('');
+            result.push(`${colors.bold}${colors.cyan}${'═'.repeat(Math.min(line.slice(2).trim().length, width))}${colors.reset}`);
+            result.push(`${colors.bold}${colors.cyan}${line.slice(2).trim()}${colors.reset}`);
+            result.push(`${colors.bold}${colors.cyan}${'═'.repeat(Math.min(line.slice(2).trim().length, width))}${colors.reset}`);
+            continue;
+        }
+        // Horizontal rules
+        if (/^[-*_]{3,}$/.test(line.trim())) {
+            result.push(`${colors.dim}${'─'.repeat(Math.min(width, 60))}${colors.reset}`);
+            continue;
+        }
+        // Blockquotes
+        if (line.startsWith('>')) {
+            const quoteText = line.slice(1).trim();
+            result.push(`${colors.dim}│${colors.reset} ${colors.italic}${quoteText}${colors.reset}`);
+            continue;
+        }
+        // Unordered lists
+        if (/^\s*[-*+]\s/.test(line)) {
+            const indent = line.match(/^(\s*)/)?.[1] || '';
+            const content = line.replace(/^\s*[-*+]\s/, '');
+            result.push(`${indent}${colors.yellow}•${colors.reset} ${renderInline(content)}`);
+            continue;
+        }
+        // Ordered lists
+        if (/^\s*\d+\.\s/.test(line)) {
+            const match = line.match(/^(\s*)(\d+)\.\s(.*)/);
+            if (match) {
+                const [, indent, num, content] = match;
+                result.push(`${indent}${colors.yellow}${num}.${colors.reset} ${renderInline(content)}`);
+                continue;
+            }
+        }
+        // Regular paragraph with inline formatting
+        result.push(renderInline(line));
+    }
+    return result.join('\n');
+}
+/**
+ * Render inline markdown elements
+ */
+function renderInline(text) {
+    // Bold **text** or __text__
+    text = text.replace(/\*\*(.+?)\*\*/g, `${colors.bold}$1${colors.reset}`);
+    text = text.replace(/__(.+?)__/g, `${colors.bold}$1${colors.reset}`);
+    // Italic *text* or _text_
+    text = text.replace(/\*([^*]+)\*/g, `${colors.italic}$1${colors.reset}`);
+    text = text.replace(/_([^_]+)_/g, `${colors.italic}$1${colors.reset}`);
+    // Inline code `text`
+    text = text.replace(/`([^`]+)`/g, `${colors.bgMagenta}${colors.white}$1${colors.reset}`);
+    // Links [text](url) - show text with underline
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, `${colors.underline}${colors.blue}$1${colors.reset}`);
+    // Strikethrough ~~text~~
+    text = text.replace(/~~(.+?)~~/g, `${colors.dim}$1${colors.reset}`);
+    return text;
+}
+/**
+ * Strip markdown formatting to get plain text
+ */
+export function stripMarkdown(text) {
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, '');
+    // Remove inline code
+    text = text.replace(/`([^`]+)`/g, '$1');
+    // Remove headers markers
+    text = text.replace(/^#{1,6}\s+/gm, '');
+    // Remove bold/italic
+    text = text.replace(/\*\*(.+?)\*\*/g, '$1');
+    text = text.replace(/__(.+?)__/g, '$1');
+    text = text.replace(/\*([^*]+)\*/g, '$1');
+    text = text.replace(/_([^_]+)_/g, '$1');
+    // Remove links but keep text
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, '$1');
+    // Remove blockquote markers
+    text = text.replace(/^>\s?/gm, '');
+    // Remove list markers
+    text = text.replace(/^\s*[-*+]\s/gm, '');
+    text = text.replace(/^\s*\d+\.\s/gm, '');
+    // Remove horizontal rules
+    text = text.replace(/^[-*_]{3,}$/gm, '');
+    return text.trim();
+}
+/**
+ * Truncate text to fit width, preserving ANSI codes
+ */
+export function truncateWithAnsi(text, maxWidth) {
+    // ANSI escape code regex
+    const ansiRegex = /\x1b\[[0-9;]*m/g;
+    let visibleLength = 0;
+    let result = '';
+    let lastIndex = 0;
+    let match;
+    // Track open ANSI codes to properly close them
+    const openCodes = [];
+    while ((match = ansiRegex.exec(text)) !== null) {
+        // Add text before this ANSI code
+        const textBefore = text.slice(lastIndex, match.index);
+        const remainingSpace = maxWidth - visibleLength;
+        if (textBefore.length <= remainingSpace) {
+            result += textBefore;
+            visibleLength += textBefore.length;
+        }
+        else {
+            result += textBefore.slice(0, remainingSpace - 1) + '…';
+            // Close any open ANSI codes
+            if (openCodes.length > 0) {
+                result += colors.reset;
+            }
+            return result;
+        }
+        // Add the ANSI code
+        result += match[0];
+        // Track open/close codes
+        if (match[0] === colors.reset) {
+            openCodes.length = 0;
+        }
+        else {
+            openCodes.push(match[0]);
+        }
+        lastIndex = match.index + match[0].length;
+    }
+    // Add remaining text
+    const remainingText = text.slice(lastIndex);
+    const remainingSpace = maxWidth - visibleLength;
+    if (remainingText.length <= remainingSpace) {
+        result += remainingText;
+    }
+    else {
+        result += remainingText.slice(0, remainingSpace - 1) + '…';
+    }
+    // Close any open ANSI codes
+    if (openCodes.length > 0) {
+        result += colors.reset;
+    }
+    return result;
+}
+/**
+ * Word wrap text while preserving ANSI codes
+ */
+export function wrapText(text, width) {
+    const words = text.split(/(\s+)/);
+    const lines = [];
+    let currentLine = '';
+    let currentLength = 0;
+    // ANSI escape code regex
+    const ansiRegex = /\x1b\[[0-9;]*m/g;
+    for (const word of words) {
+        // Calculate visible length (excluding ANSI codes)
+        const visibleLength = word.replace(ansiRegex, '').length;
+        if (currentLength + visibleLength > width && currentLine.length > 0) {
+            lines.push(currentLine.trimEnd());
+            currentLine = '';
+            currentLength = 0;
+        }
+        currentLine += word;
+        currentLength += visibleLength;
+    }
+    if (currentLine.length > 0) {
+        lines.push(currentLine.trimEnd());
+    }
+    return lines;
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@getlore/cli",
+  "version": "0.2.0",
+  "description": "Research knowledge repository with semantic search, citations, and project lineage tracking",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "lore": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "plugins",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "mcp": "node dist/mcp/server.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "knowledge-base",
+    "research",
+    "mcp",
+    "model-context-protocol",
+    "semantic-search",
+    "citations",
+    "project-management",
+    "ai-agents",
+    "claude"
+  ],
+  "author": "Mishkin Faustini",
+  "homepage": "https://getlore.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/getlore-ai/lore.git"
+  },
+  "bugs": {
+    "url": "https://github.com/getlore-ai/lore/issues"
+  },
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.22",
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@supabase/supabase-js": "^2.93.2",
+    "apache-arrow": "^18.1.0",
+    "blessed": "^0.1.81",
+    "chokidar": "^5.0.0",
+    "commander": "^12.1.0",
+    "dotenv": "^17.2.3",
+    "openai": "^4.77.0",
+    "pdf-parse": "^2.4.5",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/blessed": "^0.1.27",
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}

package/plugins/claude-code/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "lore",
+  "description": "Research knowledge repository — semantic search, citations, and agent-driven ingestion from any source",
+  "version": "1.0.0",
+  "author": {
+    "name": "Mishkin Faustini"
+  },
+  "repository": "https://github.com/getlore-ai/lore",
+  "keywords": ["knowledge-base", "research", "citations", "semantic-search", "mcp"]
+}

package/plugins/claude-code/.mcp.json

@@ -0,0 +1,6 @@
+{
+  "lore": {
+    "command": "npx",
+    "args": ["-y", "@getlore/cli", "mcp"]
+  }
+}

package/plugins/claude-code/skills/lore/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: lore
+description: Search and ingest knowledge from Lore — a research repository with citations and semantic search
+user-invocable: false
+---
+
+# Lore Knowledge Base
+
+Lore is a research knowledge repository available via MCP. It stores documents, meeting notes, interviews, and decisions with full citations back to original sources. Use it to ground your work in evidence and preserve important context.
+
+## MCP Tools
+
+| Tool | Cost | Use For |
+|------|------|---------|
+| `search` | Low | Quick lookups, finding relevant sources |
+| `get_source` | Low | Full document retrieval by ID |
+| `list_sources` | Low | Browse what exists in a project |
+| `list_projects` | Low | Discover available knowledge domains |
+| `retain` | Low | Save discrete insights/decisions |
+| `ingest` | Medium | Push full documents into the knowledge base |
+| `research` | High | Cross-reference multiple sources, synthesize findings |
+| `sync` | Variable | Refresh from configured source directories |
+
+## When to Ingest
+
+Use `ingest` to push content into Lore when:
+- Working context should be preserved for future sessions
+- Documents, specs, or research are shared that the team needs to reference later
+- You encounter important external content (from integrations, web, etc.)
+
+Always pass `source_url` (original URL for linking) and `source_name` (human-readable label like "GitHub PR #123") when available. Ingestion is idempotent — safe to call repeatedly with the same content.
+
+## When to Search
+
+Before making recommendations or answering questions about past work:
+1. `search` first — it's fast and cheap
+2. Only use `research` if the question genuinely needs cross-referencing multiple sources
+3. Use `get_source(id, include_content: true)` when you need the full text
+
+## When to Retain
+
+Use `retain` for short synthesized knowledge (not full documents):
+- Decisions made during a session
+- Key insights distilled from analysis
+- Requirements extracted from conversations
+
+## Example: Grounding a Decision
+
+```
+# 1. Check what exists
+search("database migration approach", project: "backend-rewrite")
+
+# 2. If results are relevant, get full context
+get_source("abc-123", include_content: true)
+
+# 3. After making a decision, retain it
+retain(
+  content: "Chose pgvector over Pinecone for embeddings — lower latency, simpler ops, sufficient scale",
+  project: "backend-rewrite",
+  type: "decision",
+  source_context: "Architecture review session"
+)
+```

package/plugins/codex/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: lore
+description: Search and ingest knowledge from Lore — a research repository with citations and semantic search
+---
+
+# Lore Knowledge Base
+
+Lore is a research knowledge repository available via MCP. It stores documents, meeting notes, interviews, and decisions with full citations back to original sources. Use it to ground your work in evidence and preserve important context.
+
+## MCP Tools
+
+| Tool | Cost | Use For |
+|------|------|---------|
+| `search` | Low | Quick lookups, finding relevant sources |
+| `get_source` | Low | Full document retrieval by ID |
+| `list_sources` | Low | Browse what exists in a project |
+| `list_projects` | Low | Discover available knowledge domains |
+| `retain` | Low | Save discrete insights/decisions |
+| `ingest` | Medium | Push full documents into the knowledge base |
+| `research` | High | Cross-reference multiple sources, synthesize findings |
+| `sync` | Variable | Refresh from configured source directories |
+
+## When to Ingest
+
+Use `ingest` to push content into Lore when working context should be preserved, documents are shared, or you encounter important external content. Always pass `source_url` and `source_name` when available. Ingestion is idempotent.
+
+## When to Search
+
+Before making recommendations or answering questions about past work:
+1. `search` first — it's fast and cheap
+2. Only use `research` for multi-source synthesis (10x more expensive)
+3. Use `get_source(id, include_content: true)` for full text
+
+## When to Retain
+
+Use `retain` for short synthesized knowledge (decisions, insights, requirements) — not full documents.

package/plugins/codex/agents/openai.yaml

@@ -0,0 +1,10 @@
+display_name: Lore
+description: Research knowledge repository with semantic search, citations, and agent-driven ingestion
+icon_url: https://github.com/getlore-ai/lore
+mcp_servers:
+  - name: lore
+    command: npx
+    args:
+      - "-y"
+      - "@getlore/cli"
+      - mcp

package/plugins/gemini/GEMINI.md

@@ -0,0 +1,31 @@
+# Lore Knowledge Base
+
+Lore is a research knowledge repository available via MCP. It stores documents, meeting notes, interviews, and decisions with full citations back to original sources. Use it to ground your work in evidence and preserve important context.
+
+## MCP Tools
+
+| Tool | Cost | Use For |
+|------|------|---------|
+| `search` | Low | Quick lookups, finding relevant sources |
+| `get_source` | Low | Full document retrieval by ID |
+| `list_sources` | Low | Browse what exists in a project |
+| `list_projects` | Low | Discover available knowledge domains |
+| `retain` | Low | Save discrete insights/decisions |
+| `ingest` | Medium | Push full documents into the knowledge base |
+| `research` | High | Cross-reference multiple sources, synthesize findings |
+| `sync` | Variable | Refresh from configured source directories |
+
+## When to Ingest
+
+Use `ingest` to push content into Lore when working context should be preserved, documents are shared, or you encounter important external content. Always pass `source_url` and `source_name` when available. Ingestion is idempotent.
+
+## When to Search
+
+Before making recommendations or answering questions about past work:
+1. `search` first — it's fast and cheap
+2. Only use `research` for multi-source synthesis (10x more expensive)
+3. Use `get_source(id, include_content: true)` for full text
+
+## When to Retain
+
+Use `retain` for short synthesized knowledge (decisions, insights, requirements) — not full documents.

package/plugins/gemini/gemini-extension.json

@@ -0,0 +1,11 @@
+{
+  "name": "lore",
+  "version": "1.0.0",
+  "description": "Research knowledge repository — semantic search, citations, and agent-driven ingestion from any source",
+  "mcpServers": {
+    "lore": {
+      "command": "npx",
+      "args": ["-y", "@getlore/cli", "mcp"]
+    }
+  }
+}

package/skills/generic-agent.md

@@ -0,0 +1,99 @@
+# Lore Knowledge Base — Agent Instructions
+
+Lore is a research knowledge repository accessible via MCP (Model Context Protocol). It stores documents with full-text search, semantic search, and citation tracking. Content is deduplicated, embedded for retrieval, and organized by project.
+
+## Core Concepts
+
+- **Sources**: Full documents (meeting notes, interviews, Slack threads, specs, etc.)
+- **Projects**: Organizational grouping for sources
+- **Insights**: Short retained knowledge (decisions, requirements, observations)
+- **Citations**: Every piece of knowledge links back to its original source
+
+## Tools Reference
+
+### `ingest` — Push content into Lore
+The primary way to add content. Accepts any document with metadata.
+
+```json
+{
+  "content": "Full document text...",
+  "title": "Sprint Planning — Jan 15",
+  "project": "my-project",
+  "source_type": "meeting",
+  "source_url": "https://meet.google.com/abc-123",
+  "source_name": "Google Meet",
+  "participants": ["Alice", "Bob"],
+  "tags": ["sprint", "planning"]
+}
+```
+
+- **Idempotent**: Duplicate content returns `{deduplicated: true}` with no processing cost.
+- **source_type**: Free-form string. Common values: `meeting`, `interview`, `document`, `notes`, `analysis`, `conversation`, `slack`, `email`, `github-issue`, `notion`.
+- **source_url**: Always pass when available — enables citation linking.
+- **source_name**: Human-readable origin label.
+
+### `search` — Find relevant sources
+Fast lookup. Returns summaries with relevance scores.
+
+```json
+{
+  "query": "user feedback on export speed",
+  "project": "my-project",
+  "mode": "hybrid",
+  "limit": 5
+}
+```
+
+Modes:
+- `hybrid` (default): Combined vector + full-text search. Best for most queries.
+- `semantic`: Vector similarity only. For conceptual queries.
+- `keyword`: Full-text only. For exact terms, names, identifiers.
+- `regex`: Pattern matching. For code patterns or complex text matching.
+
+### `get_source` — Retrieve full document
+Get complete details of a source by ID. Set `include_content: true` for the full text.
+
+### `list_sources` — Browse sources
+List sources filtered by project or type. Sorted by date (newest first).
+
+### `list_projects` — Discover projects
+Lists all projects with source counts and activity dates.
+
+### `retain` — Save discrete knowledge
+For short insights, decisions, or requirements — not full documents.
+
+```json
+{
+  "content": "Users consistently report export takes >30s for large datasets",
+  "project": "my-project",
+  "type": "insight",
+  "source_context": "User interview synthesis — Jan batch"
+}
+```
+
+### `research` — Deep research with citations
+Runs an internal agent that iteratively searches, reads, and synthesizes findings.
+
+```json
+{
+  "task": "What authentication approach should we use based on user feedback?",
+  "project": "my-project"
+}
+```
+
+**Cost warning**: Makes 3-8 internal LLM calls. Use `search` for simple lookups.
+
+### `sync` — Refresh from source directories
+Scans configured directories for new files. Use `ingest` for agent-pushed content instead.
+
+### `archive_project` — Archive a project
+Excludes from default search. Only use when explicitly requested.
+
+## Best Practices
+
+1. **Search before you answer**: If a question might have documented context, search Lore first.
+2. **Ingest what matters**: After meaningful conversations or when processing external content, ingest it.
+3. **Always pass source_url**: Enables citation linking back to the original.
+4. **Use retain for synthesis**: After analyzing multiple sources, retain the key insight.
+5. **Prefer search over research**: `search` is 10x cheaper. Only use `research` for multi-source synthesis.
+6. **Cite your sources**: When presenting Lore results, reference the source title and date.

package/skills/openclaw.md

@@ -0,0 +1,67 @@
+---
+name: lore
+description: Search and ingest knowledge from Lore, a research repository with citations
+version: "1.0"
+user-invocable: false
+---
+
+# Lore Knowledge Base
+
+Lore is a research knowledge repository you have access to via MCP tools. It stores documents, meeting notes, interviews, and decisions with full citations — not just summaries, but the original content linked back to its source. Use it to ground your answers in evidence and to preserve important context from your conversations.
+
+## When to Ingest Content into Lore
+
+Push content into Lore using the `ingest` tool whenever you encounter information worth preserving:
+
+- **After conversations**: When a user shares meeting notes, interview transcripts, or important documents, ingest them so they're searchable later.
+- **External content**: When you fetch content from Slack, Notion, GitHub, email, or other systems, ingest the relevant parts into Lore.
+- **Decisions and context**: When important decisions are made or context is shared that future conversations will need.
+
+Always include:
+- `source_url`: The original URL (Slack permalink, Notion page URL, GitHub issue URL) for citation linking.
+- `source_name`: A human-readable label like "Slack #product-team" or "GitHub issue #42".
+- `project`: The project this content belongs to.
+
+Ingestion is idempotent — calling `ingest` with the same content twice is safe and cheap (returns immediately with `deduplicated: true`).
+
+## When to Search Lore
+
+Before answering questions about past decisions, user feedback, project history, or anything that might already be documented:
+
+1. **Use `search`** for quick lookups. Pick the right mode:
+   - `hybrid` (default): Best for most queries
+   - `keyword`: For exact terms, names, identifiers
+   - `semantic`: For conceptual queries ("user frustrations", "pain points")
+
+2. **Use `research`** only when the question requires cross-referencing multiple sources or synthesizing findings. It costs 10x more than `search` — don't use it for simple lookups.
+
+3. **Use `get_source`** with `include_content=true` when you need the full original text of a specific document.
+
+## When to Retain Insights
+
+Use `retain` (not `ingest`) for short, discrete pieces of knowledge:
+- Key decisions: "We chose X because Y"
+- Synthesized insights: "3/5 users mentioned Z as their top issue"
+- Requirements: "Must support SSO for enterprise"
+
+## Citation Best Practices
+
+When presenting information from Lore, always cite your sources:
+- Reference the source title and date
+- Quote directly when possible
+- If a `source_url` is available, link to the original
+
+## Example Workflows
+
+**User asks about past decisions:**
+1. `search("authentication approach decisions", project: "my-app")`
+2. Review results, get full source if needed: `get_source(source_id, include_content: true)`
+3. Present findings with citations
+
+**User shares meeting notes:**
+1. `ingest(content: "...", title: "Sprint Planning Jan 15", project: "my-app", source_type: "meeting", source_name: "Google Meet", participants: ["Alice", "Bob"])`
+2. Confirm ingestion to user
+
+**User asks a broad research question:**
+1. `research(task: "What do users think about our onboarding flow?", project: "my-app")`
+2. Present the synthesized findings with citations