@voidwire/lore 0.1.0 → 0.1.2

package/cli.ts

@@ -21,6 +21,7 @@
 
 import {
   search,
+  searchPrismis,
   listSources,
   list,
   listDomains,
@@ -112,14 +113,27 @@ function fail(error: string, code: number = 1): never {
 // ============================================================================
 
 function handleSearch(args: string[]): void {
+  if (hasFlag(args, "help")) {
+    showSearchHelp();
+  }
+
   const parsed = parseArgs(args);
   const positional = getPositionalArgs(args);
 
   // Handle --sources flag
   if (hasFlag(args, "sources")) {
-    const sources = listSources();
+    const indexed = listSources();
+    const passthrough = [
+      { source: "prismis", count: null, type: "passthrough" },
+    ];
+    const sources = [
+      ...indexed.map((s) => ({ ...s, type: "indexed" })),
+      ...passthrough,
+    ];
     output({ success: true, sources });
-    console.error(`✅ ${sources.length} sources indexed`);
+    console.error(
+      `✅ ${indexed.length} indexed sources + ${passthrough.length} passthrough`,
+    );
     process.exit(0);
   }
 
@@ -141,6 +155,28 @@ function handleSearch(args: string[]): void {
   const limit = parsed.has("limit") ? parseInt(parsed.get("limit")!, 10) : 20;
   const since = parsed.get("since");
 
+  // Handle prismis passthrough
+  if (source === "prismis") {
+    searchPrismis(query, { limit })
+      .then((results) => {
+        output({
+          success: true,
+          results,
+          count: results.length,
+        });
+        console.error(
+          `✅ ${results.length} result${results.length !== 1 ? "s" : ""} found`,
+        );
+        process.exit(0);
+      })
+      .catch((error) => {
+        const message =
+          error instanceof Error ? error.message : "Unknown error";
+        fail(message, 2);
+      });
+    return;
+  }
+
   try {
     const results = search(query, { source, limit, since });
     output({
@@ -176,6 +212,10 @@ function formatHumanOutput(result: ListResult): string {
 }
 
 function handleList(args: string[]): void {
+  if (hasFlag(args, "help")) {
+    showListHelp();
+  }
+
   const parsed = parseArgs(args);
   const positional = getPositionalArgs(args);
 
@@ -319,6 +359,10 @@ function handleCaptureNote(args: string[]): void {
 }
 
 function handleCapture(args: string[]): void {
+  if (hasFlag(args, "help")) {
+    showCaptureHelp();
+  }
+
   if (args.length === 0) {
     fail("Missing capture type. Use: task, knowledge, or note");
   }
@@ -369,6 +413,9 @@ Search Options:
   --since <date>    Filter by date (today, yesterday, this-week, YYYY-MM-DD)
   --sources         List indexed sources with counts
 
+Passthrough Sources:
+  prismis           Semantic search via prismis daemon (requires prismis-daemon running)
+
 List Options:
   --limit <n>       Maximum entries
   --format <fmt>    Output format: json (default), jsonl, human
@@ -401,10 +448,140 @@ Examples:
   process.exit(0);
 }
 
+function showSearchHelp(): void {
+  console.log(`
+lore search - Search indexed knowledge
+
+Usage:
+  lore search <query>                   Search all sources
+  lore search <source> <query>          Search specific source
+  lore search --sources                 List indexed sources
+
+Options:
+  --limit <n>       Maximum results (default: 20)
+  --since <date>    Filter by date (today, yesterday, this-week, YYYY-MM-DD)
+  --sources         List indexed sources with counts
+  --help            Show this help
+
+Indexed Sources:
+  blogs             Blog posts and articles
+  captures          Quick captures and notes
+  commits           Git commit history
+  development       Active development projects
+  events            Calendar events and meetings
+  explorations      Technical explorations
+  obsidian          Obsidian vault notes
+  personal          Personal data (books, movies, etc.)
+  readmes           Project README files
+  sessions          Claude Code session transcripts
+  tasks             Logged development tasks
+
+Passthrough Sources:
+  prismis           Semantic search via prismis daemon
+                    (requires prismis-daemon running)
+
+Examples:
+  lore search "authentication"
+  lore search blogs "typescript patterns"
+  lore search commits --since this-week "refactor"
+  lore search prismis "kubernetes security"
+`);
+  process.exit(0);
+}
+
+function showListHelp(): void {
+  console.log(`
+lore list - List domain entries
+
+Usage:
+  lore list <domain>                    List entries in domain
+  lore list --domains                   List available domains
+
+Options:
+  --limit <n>       Maximum entries (default: all)
+  --format <fmt>    Output format: json (default), jsonl, human
+  --domains         List available domains
+  --help            Show this help
+
+Available Domains:
+  blogs             Blog posts
+  books             Books read
+  captures          Quick captures
+  commits           Git commits
+  development       Development projects
+  events            Calendar events
+  explorations      Technical explorations
+  habits            Tracked habits
+  interests         Personal interests
+  movies            Movies watched
+  obsidian          Obsidian notes
+  people            People/contacts
+  personal          Personal data aggregate
+  podcasts          Podcasts listened
+  readmes           Project READMEs
+  sessions          Claude Code sessions
+  tasks             Development tasks
+
+Examples:
+  lore list development
+  lore list commits --limit 10 --format human
+  lore list books --format jsonl
+`);
+  process.exit(0);
+}
+
+function showCaptureHelp(): void {
+  console.log(`
+lore capture - Capture knowledge
+
+Usage:
+  lore capture task                     Log task completion
+  lore capture knowledge                Log insight/learning
+  lore capture note                     Quick note
+
+Capture Types:
+
+  task - Log completed development task
+    Required:
+      --project       Project name
+      --name          Task name
+      --problem       Problem solved
+      --solution      Solution pattern
+    Optional:
+      --code          Code snippet
+      --discoveries   Comma-separated discoveries
+      --deviations    Deviation from plan
+      --pattern       Pattern name
+      --keywords      Comma-separated keywords
+      --tech          Comma-separated technologies
+      --difficulty    Difficulty level
+
+  knowledge - Log insight or learning
+    Required:
+      --context       Context/project name
+      --text          Insight text
+      --type          Type: decision, learning, gotcha, preference
+
+  note - Quick note capture
+    Required:
+      --text          Note content
+    Optional:
+      --tags          Comma-separated tags
+      --context       Optional context
+
+Examples:
+  lore capture task --project=lore --name="Add help" --problem="No subcommand help" --solution="Added per-command help functions"
+  lore capture knowledge --context=lore --text="Unified CLI works" --type=learning
+  lore capture note --text="Remember to update docs" --tags=docs,todo
+`);
+  process.exit(0);
+}
+
 function main(): void {
   const args = process.argv.slice(2);
 
-  if (args.length === 0 || hasFlag(args, "help") || args[0] === "-h") {
+  // Show global help only when no args or help is first arg
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     showHelp();
   }
 
@@ -421,10 +598,6 @@ function main(): void {
     case "capture":
       handleCapture(commandArgs);
       break;
-    case "--help":
-    case "-h":
-      showHelp();
-      break;
     default:
       fail(`Unknown command: ${command}. Use: search, list, or capture`);
   }

package/index.ts

@@ -27,6 +27,13 @@ export {
   type ListResult,
 } from "./lib/list";
 
+// Prismis integration
+export {
+  searchPrismis,
+  type PrismisSearchResult,
+  type PrismisSearchOptions,
+} from "./lib/prismis";
+
 // Capture
 export {
   captureKnowledge,

package/lib/capture.ts

@@ -12,6 +12,7 @@ import { homedir } from "os";
 export interface CaptureResult {
   success: boolean;
   error?: string;
+  [key: string]: unknown;
 }
 
 export type KnowledgeCaptureType =

package/lib/prismis.ts

@@ -0,0 +1,168 @@
+/**
+ * Prismis API integration
+ *
+ * Queries prismis daemon REST API for semantic search across content.
+ * Reads host and API key from ~/.config/prismis/config.toml
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// Local interface to avoid bun:sqlite dependency from search.ts
+export interface PrismisSearchResult {
+  source: string;
+  title: string;
+  content: string;
+  metadata: string;
+  rank: number;
+}
+
+const DEFAULT_PORT = 8989;
+const PRISMIS_CONFIG_PATH = join(
+  process.env.HOME ?? "",
+  ".config",
+  "prismis",
+  "config.toml",
+);
+
+export interface PrismisSearchOptions {
+  limit?: number;
+}
+
+interface PrismisConfig {
+  host: string;
+  apiKey: string;
+}
+
+interface PrismisItem {
+  id: string;
+  title: string;
+  url: string;
+  priority: string;
+  relevance_score: number;
+  published_at: string;
+  source_name: string;
+  summary: string;
+}
+
+interface PrismisResponse {
+  success: boolean;
+  message: string;
+  data: {
+    items: PrismisItem[];
+    total: number;
+  };
+}
+
+/**
+ * Read prismis config from config.toml
+ */
+function readPrismisConfig(): PrismisConfig {
+  if (!existsSync(PRISMIS_CONFIG_PATH)) {
+    throw new Error(
+      `Prismis config not found at ${PRISMIS_CONFIG_PATH}. ` +
+        "Install prismis and run: prismis-cli source add <url>",
+    );
+  }
+
+  const content = readFileSync(PRISMIS_CONFIG_PATH, "utf-8");
+
+  // Parse [api] section
+  const keyMatch = content.match(/\[api\][^[]*key\s*=\s*"([^"]+)"/);
+  if (!keyMatch) {
+    throw new Error(
+      "Prismis API key not found in config.toml. Add [api] key=... to config.",
+    );
+  }
+
+  const hostMatch = content.match(/\[api\][^[]*host\s*=\s*"([^"]+)"/);
+  let host = hostMatch?.[1] ?? "localhost";
+
+  // Map server bind addresses to client-usable addresses
+  if (host === "0.0.0.0" || host === "127.0.0.1") {
+    host = "localhost";
+  }
+
+  return {
+    host,
+    apiKey: keyMatch[1],
+  };
+}
+
+/**
+ * Check if prismis daemon is running
+ */
+async function checkPrismisDaemon(apiBase: string): Promise<void> {
+  try {
+    const response = await fetch(`${apiBase}/health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+
+    if (!response.ok) {
+      throw new Error("Prismis daemon unhealthy");
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw new Error(
+        `Prismis daemon not responding at ${apiBase}. Start with: prismis-daemon`,
+      );
+    }
+    throw new Error(
+      `Prismis daemon not running at ${apiBase}. Start with: prismis-daemon`,
+    );
+  }
+}
+
+/**
+ * Search prismis content via API
+ */
+export async function searchPrismis(
+  query: string,
+  options: PrismisSearchOptions = {},
+): Promise<PrismisSearchResult[]> {
+  // Read config
+  const config = readPrismisConfig();
+  const apiBase = `http://${config.host}:${DEFAULT_PORT}`;
+
+  // Check daemon is running
+  await checkPrismisDaemon(apiBase);
+
+  // Build search URL
+  const params = new URLSearchParams({
+    q: query,
+    limit: String(options.limit ?? 20),
+    compact: "true",
+  });
+
+  const response = await fetch(`${apiBase}/api/search?${params}`, {
+    headers: {
+      "X-API-Key": config.apiKey,
+    },
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Prismis API error (${response.status}): ${text}`);
+  }
+
+  const data: PrismisResponse = await response.json();
+
+  if (!data.success) {
+    throw new Error(`Prismis search failed: ${data.message}`);
+  }
+
+  // Map prismis items to SearchResult format
+  return data.data.items.map((item) => ({
+    source: "prismis",
+    title: item.title,
+    content: item.summary || "",
+    metadata: JSON.stringify({
+      id: item.id,
+      url: item.url,
+      priority: item.priority,
+      published_at: item.published_at,
+      source_name: item.source_name,
+    }),
+    rank: item.relevance_score,
+  }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidwire/lore",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Unified knowledge CLI - Search, list, and capture your indexed knowledge",
   "type": "module",
   "main": "./index.ts",
@@ -18,9 +18,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "test": "bun test"
-  },
   "keywords": [
     "knowledge",
     "search",
@@ -46,5 +43,8 @@
   },
   "devDependencies": {
     "bun-types": "latest"
+  },
+  "scripts": {
+    "test": "bun test"
   }
-}
+}