recallnest 2.2.1 → 2.5.4

package/config.json.example

@@ -28,11 +28,14 @@
     }
   },
   "retrieval": {
-    "mode": "hybrid",
+    "mode": "vector",
     "vectorWeight": 0.7,
     "bm25Weight": 0.3,
     "recencyHalfLifeDays": 30,
     "timeDecayHalfLifeDays": 120,
     "hardMinScore": 0.3
+  },
+  "scopeRelations": {
+    "project:example-a": ["project:example-b"]
   }
 }

package/connectors/examples/email-adapter.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env bun
+/**
+ * Email Connector Adapter (skeleton)
+ *
+ * Demonstrates how to produce a ConnectorOutputV1 JSON file from an email
+ * source (IMAP, Gmail API, local mbox, etc.) for RecallNest ingestion.
+ *
+ * Usage:
+ *   bun run connectors/examples/email-adapter.ts > email-output.json
+ *   lm ingest --connector email-output.json
+ *
+ * Customize:
+ *   1. Replace the fetchEmails() stub with your IMAP/API client
+ *   2. Adjust scope to match your project naming
+ *   3. Set categoryHint based on email type (meeting invite → "events", etc.)
+ */
+
+import type { ConnectorOutputV1 } from "../../src/connector-types.js";
+import { createHash } from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// TODO: Replace with real email fetching logic
+// ---------------------------------------------------------------------------
+
+interface RawEmail {
+  messageId: string;
+  subject: string;
+  body: string;
+  from: string;
+  date: string; // ISO 8601
+}
+
+async function fetchEmails(_since: Date): Promise<RawEmail[]> {
+  // Example: use imapflow, googleapis, or read from .mbox
+  // const client = new ImapFlow({ host: 'imap.example.com', ... });
+  // await client.connect();
+  // const messages = await client.fetch(...);
+  return []; // Replace with real implementation
+}
+
+// ---------------------------------------------------------------------------
+// Transform → ConnectorOutputV1
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const since = new Date(Date.now() - 7 * 86_400_000); // last 7 days
+  const emails = await fetchEmails(since);
+
+  const output: ConnectorOutputV1 = {
+    version: "connector-v1",
+    source: "email",
+    scope: "inbox:personal",           // Customize: "inbox:work", "project:xyz"
+    producedAt: new Date().toISOString(),
+    records: emails.map((email) => ({
+      id: `email:${email.messageId}`,
+      text: email.body,
+      title: email.subject,
+      categoryHint: "events",          // Customize per email type
+      importanceHint: 0.6,             // Customize: 0.9 for flagged/starred
+      tags: ["email", `from:${email.from}`],
+      timestamp: email.date,
+      contentHash: createHash("sha256").update(email.body).digest("hex"),
+      sourceMetadata: {
+        from: email.from,
+        messageId: email.messageId,
+      },
+    })),
+  };
+
+  console.log(JSON.stringify(output, null, 2));
+}
+
+main().catch(console.error);

package/connectors/examples/logs-adapter.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+/**
+ * Log File Connector Adapter (skeleton)
+ *
+ * Demonstrates how to produce a ConnectorOutputV1 JSON file from application
+ * log files for RecallNest ingestion. Useful for tracking deploy events,
+ * error patterns, and operational decisions.
+ *
+ * Usage:
+ *   bun run connectors/examples/logs-adapter.ts /var/log/myapp/*.log > logs-output.json
+ *   lm ingest --connector logs-output.json
+ *
+ * Customize:
+ *   1. Replace parseLogLine() with your log format parser
+ *   2. Adjust the importance/category logic for your use case
+ *   3. Set scope to match your project
+ */
+
+import type { ConnectorOutputV1 } from "../../src/connector-types.js";
+import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// TODO: Replace with your log format parser
+// ---------------------------------------------------------------------------
+
+interface ParsedLogEntry {
+  timestamp: string;  // ISO 8601
+  level: "info" | "warn" | "error" | "debug";
+  message: string;
+  source?: string;    // e.g. module name, service
+}
+
+function parseLogLine(line: string): ParsedLogEntry | null {
+  // Example: "2026-04-14T10:00:00Z [ERROR] auth: login failed for user@example.com"
+  const match = line.match(
+    /^(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)\s+\[(\w+)]\s+(?:(\w+):\s+)?(.+)$/,
+  );
+  if (!match) return null;
+  return {
+    timestamp: match[1],
+    level: match[2].toLowerCase() as ParsedLogEntry["level"],
+    source: match[3],
+    message: match[4],
+  };
+}
+
+function levelToImportance(level: string): number {
+  switch (level) {
+    case "error": return 0.9;
+    case "warn":  return 0.7;
+    case "info":  return 0.5;
+    default:      return 0.3;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Transform → ConnectorOutputV1
+// ---------------------------------------------------------------------------
+
+function main() {
+  const files = process.argv.slice(2);
+  if (files.length === 0) {
+    console.error("Usage: logs-adapter.ts <logfile> [logfile...]");
+    process.exit(1);
+  }
+
+  const records: ConnectorOutputV1["records"] = [];
+
+  for (const file of files) {
+    const lines = readFileSync(file, "utf-8").split("\n").filter(Boolean);
+    for (const line of lines) {
+      const entry = parseLogLine(line);
+      if (!entry) continue;
+
+      // Skip debug-level by default — too noisy for memory storage
+      if (entry.level === "debug") continue;
+
+      records.push({
+        id: `log:${createHash("md5").update(line).digest("hex")}`,
+        text: entry.message,
+        title: entry.source ? `[${entry.level.toUpperCase()}] ${entry.source}` : undefined,
+        categoryHint: entry.level === "error" ? "cases" : "events",
+        importanceHint: levelToImportance(entry.level),
+        tags: ["log", entry.level, ...(entry.source ? [`module:${entry.source}`] : [])],
+        timestamp: entry.timestamp,
+        contentHash: createHash("sha256").update(line).digest("hex"),
+      });
+    }
+  }
+
+  const output: ConnectorOutputV1 = {
+    version: "connector-v1",
+    source: "logs",
+    scope: "ops:myapp",               // Customize: "project:xyz", "ops:production"
+    producedAt: new Date().toISOString(),
+    records,
+  };
+
+  console.log(JSON.stringify(output, null, 2));
+}
+
+main();

package/connectors/examples/rss-adapter.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+/**
+ * RSS Feed Connector Adapter (skeleton)
+ *
+ * Demonstrates how to produce a ConnectorOutputV1 JSON file from RSS/Atom
+ * feeds for RecallNest ingestion. Useful for tracking industry news,
+ * blog posts, and research updates.
+ *
+ * Usage:
+ *   bun run connectors/examples/rss-adapter.ts > rss-output.json
+ *   lm ingest --connector rss-output.json
+ *
+ * Customize:
+ *   1. Replace fetchFeed() with your RSS parsing library (e.g. rss-parser)
+ *   2. Adjust feed URLs and scope
+ *   3. Set categoryHint / importanceHint based on feed type
+ */
+
+import type { ConnectorOutputV1 } from "../../src/connector-types.js";
+import { createHash } from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// TODO: Replace with real RSS/Atom parsing
+// ---------------------------------------------------------------------------
+
+interface FeedItem {
+  guid: string;
+  title: string;
+  content: string;        // HTML stripped to plain text
+  link: string;
+  pubDate: string;         // ISO 8601
+  categories?: string[];
+}
+
+interface FeedConfig {
+  url: string;
+  scope: string;           // e.g. "feeds:ai-news"
+  categoryHint?: string;
+  importanceHint?: number;
+}
+
+const FEEDS: FeedConfig[] = [
+  // Add your feeds here:
+  // { url: "https://example.com/feed.xml", scope: "feeds:example" },
+];
+
+async function fetchFeed(_url: string): Promise<FeedItem[]> {
+  // Example with rss-parser:
+  // import Parser from "rss-parser";
+  // const parser = new Parser();
+  // const feed = await parser.parseURL(url);
+  // return feed.items.map(item => ({ ... }));
+  return []; // Replace with real implementation
+}
+
+// ---------------------------------------------------------------------------
+// Transform → ConnectorOutputV1
+// ---------------------------------------------------------------------------
+
+async function main() {
+  for (const feed of FEEDS) {
+    const items = await fetchFeed(feed.url);
+
+    const output: ConnectorOutputV1 = {
+      version: "connector-v1",
+      source: "rss",
+      scope: feed.scope,
+      producedAt: new Date().toISOString(),
+      records: items.map((item) => ({
+        id: `rss:${createHash("md5").update(item.guid || item.link).digest("hex")}`,
+        text: item.content,
+        title: item.title,
+        categoryHint: feed.categoryHint ?? "knowledge",
+        importanceHint: feed.importanceHint ?? 0.6,
+        tags: [
+          "rss",
+          ...(item.categories ?? []),
+          `link:${item.link}`,
+        ],
+        timestamp: item.pubDate,
+        contentHash: createHash("sha256").update(item.content).digest("hex"),
+        sourceMetadata: {
+          feedUrl: feed.url,
+          link: item.link,
+          guid: item.guid,
+        },
+      })),
+    };
+
+    // Each feed outputs one JSON — pipe to separate files if needed
+    console.log(JSON.stringify(output, null, 2));
+  }
+}
+
+main().catch(console.error);