@voidwire/lore 0.1.2 → 0.1.3

package/README.md

@@ -35,6 +35,20 @@ lore capture task|knowledge|note       # Capture knowledge
 - `--since <date>` — Filter by date (today, yesterday, this-week, YYYY-MM-DD)
 - `--sources` — List indexed sources with counts
 
+### Passthrough Sources
+
+Some sources query external services rather than the local index:
+
+```bash
+lore search prismis "kubernetes security"    # Semantic search via prismis
+```
+
+| Source | Description | Requires |
+|--------|-------------|----------|
+| `prismis` | Semantic search across saved articles | prismis-daemon running |
+
+Passthrough sources appear in `lore search --sources` with `type: "passthrough"`.
+
 ### List Options
 
 - `--limit <n>` — Maximum entries

package/cli.ts

@@ -22,6 +22,7 @@
 import {
   search,
   searchPrismis,
+  searchAtuin,
   listSources,
   list,
   listDomains,
@@ -73,7 +74,21 @@ function parseArgs(args: string[]): Map<string, string> {
 }
 
 function getPositionalArgs(args: string[]): string[] {
-  return args.filter((arg) => !arg.startsWith("--"));
+  const result: string[] = [];
+  let skipNext = false;
+  for (const arg of args) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      // Skip this flag and its value (if next arg doesn't start with -)
+      skipNext = true;
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
 }
 
 function hasFlag(args: string[], flag: string): boolean {
@@ -125,6 +140,7 @@ function handleSearch(args: string[]): void {
     const indexed = listSources();
     const passthrough = [
       { source: "prismis", count: null, type: "passthrough" },
+      { source: "atuin", count: null, type: "passthrough" },
     ];
     const sources = [
       ...indexed.map((s) => ({ ...s, type: "indexed" })),
@@ -177,6 +193,26 @@ function handleSearch(args: string[]): void {
     return;
   }
 
+  // Handle atuin passthrough
+  if (source === "atuin") {
+    try {
+      const results = searchAtuin(query, { limit });
+      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({
@@ -415,6 +451,7 @@ Search Options:
 
 Passthrough Sources:
   prismis           Semantic search via prismis daemon (requires prismis-daemon running)
+  atuin             Shell history search (queries ~/.local/share/atuin/history.db directly)
 
 List Options:
   --limit <n>       Maximum entries
@@ -479,12 +516,15 @@ Indexed Sources:
 Passthrough Sources:
   prismis           Semantic search via prismis daemon
                     (requires prismis-daemon running)
+  atuin             Shell history search
+                    (queries ~/.local/share/atuin/history.db directly)
 
 Examples:
   lore search "authentication"
   lore search blogs "typescript patterns"
   lore search commits --since this-week "refactor"
   lore search prismis "kubernetes security"
+  lore search atuin "docker build"
 `);
   process.exit(0);
 }

package/index.ts

@@ -34,6 +34,13 @@ export {
   type PrismisSearchOptions,
 } from "./lib/prismis";
 
+// Atuin integration
+export {
+  searchAtuin,
+  type AtuinSearchResult,
+  type AtuinSearchOptions,
+} from "./lib/atuin";
+
 // Capture
 export {
   captureKnowledge,

package/lib/atuin.ts

@@ -0,0 +1,160 @@
+/**
+ * Atuin shell history integration
+ *
+ * Queries Atuin SQLite database directly for shell command history.
+ * Filters sensitive commands containing passwords, tokens, secrets, API keys.
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { Database } from "bun:sqlite";
+
+export interface AtuinSearchResult {
+  source: string;
+  title: string;
+  content: string;
+  metadata: string;
+  rank: number;
+}
+
+export interface AtuinSearchOptions {
+  limit?: number;
+  cwd?: string;
+  exitCode?: number;
+}
+
+const ATUIN_DB_PATH = join(
+  process.env.HOME ?? "",
+  ".local",
+  "share",
+  "atuin",
+  "history.db",
+);
+
+// Patterns that indicate sensitive data - exclude these commands
+const SENSITIVE_PATTERNS = [
+  "%--password%",
+  "%--token%",
+  "%--secret%",
+  "%PASSWORD=%",
+  "%TOKEN=%",
+  "%SECRET=%",
+  "%API_KEY=%",
+  "%APIKEY=%",
+  "%_KEY=%",
+  "export %KEY%",
+  "export %TOKEN%",
+  "export %SECRET%",
+  "export %PASSWORD%",
+  "%X-API-Key:%",
+  "%Authorization:%",
+  "echo $%KEY%",
+  "echo $%TOKEN%",
+  "echo $%SECRET%",
+];
+
+interface AtuinRow {
+  command: string;
+  cwd: string;
+  exit: number;
+  duration: number;
+  timestamp: number;
+  hostname: string;
+}
+
+/**
+ * Search Atuin shell history
+ */
+export function searchAtuin(
+  query: string,
+  options: AtuinSearchOptions = {},
+): AtuinSearchResult[] {
+  if (!existsSync(ATUIN_DB_PATH)) {
+    throw new Error(
+      `Atuin database not found at ${ATUIN_DB_PATH}. ` +
+        "Install Atuin: https://atuin.sh",
+    );
+  }
+
+  const db = new Database(ATUIN_DB_PATH, { readonly: true });
+  const limit = options.limit ?? 20;
+
+  try {
+    // Build WHERE clause with sensitive data filtering
+    const conditions = [
+      "deleted_at IS NULL",
+      "command LIKE ?",
+      ...SENSITIVE_PATTERNS.map(() => "command NOT LIKE ?"),
+    ];
+
+    if (options.cwd) {
+      conditions.push("cwd = ?");
+    }
+
+    if (options.exitCode !== undefined) {
+      conditions.push("exit = ?");
+    }
+
+    const whereClause = conditions.join(" AND ");
+
+    const sql = `
+      SELECT command, cwd, exit, duration, timestamp, hostname
+      FROM history
+      WHERE ${whereClause}
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `;
+
+    // Build parameters
+    const params: (string | number)[] = [`%${query}%`, ...SENSITIVE_PATTERNS];
+
+    if (options.cwd) {
+      params.push(options.cwd);
+    }
+
+    if (options.exitCode !== undefined) {
+      params.push(options.exitCode);
+    }
+
+    params.push(limit);
+
+    const stmt = db.prepare(sql);
+    const rows = stmt.all(...params) as AtuinRow[];
+
+    return rows.map((row, index) => {
+      // Convert nanosecond timestamp to ISO date
+      const timestampSec = Math.floor(row.timestamp / 1_000_000_000);
+      const date = new Date(timestampSec * 1000);
+      const dateStr = date.toISOString().split("T")[0];
+
+      // Convert duration from nanoseconds to milliseconds
+      const durationMs = Math.floor(row.duration / 1_000_000);
+
+      // Build title: truncate command to 80 chars
+      const title =
+        row.command.length > 80
+          ? `[shell] ${row.command.slice(0, 77)}...`
+          : `[shell] ${row.command}`;
+
+      // Normalize cwd
+      const cwd = row.cwd === "unknown" ? "" : row.cwd;
+
+      return {
+        source: "atuin",
+        title,
+        content: row.command,
+        metadata: JSON.stringify({
+          command: row.command,
+          cwd,
+          exit_code: row.exit,
+          duration_ms: durationMs,
+          date: dateStr,
+          hostname: row.hostname,
+        }),
+        rank: -index, // Simple ranking by recency
+      };
+    });
+  } finally {
+    db.close();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidwire/lore",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Unified knowledge CLI - Search, list, and capture your indexed knowledge",
   "type": "module",
   "main": "./index.ts",
@@ -18,6 +18,9 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "test": "bun test"
+  },
   "keywords": [
     "knowledge",
     "search",
@@ -42,9 +45,6 @@
     "bun": ">=1.0.0"
   },
   "devDependencies": {
-    "bun-types": "latest"
-  },
-  "scripts": {
-    "test": "bun test"
+    "bun-types": "1.3.5"
   }
-}
+}