bikky 0.3.13 → 0.4.1

package/dist/config.d.ts

@@ -76,11 +76,67 @@ export interface WatcherConfig {
         path: string;
     };
 }
+/**
+ * One Qdrant routing target. Each destination is fully self-contained: its own
+ * URL, API key, collection name, and match rules. All fields in `match` are
+ * arrays of regex strings; OR semantics within a destination's match block,
+ * first-match-wins across destinations.
+ */
+export interface DestinationMatch {
+    /** Match against `process.cwd()`. */
+    cwd?: string[];
+    /** Match against any of the input `entities`. */
+    entity?: string[];
+    /** Match against the input `content`. */
+    content?: string[];
+    /** Per-key match against the input `metadata`. */
+    metadata?: Record<string, string[]>;
+}
+export interface Destination {
+    /** Stable, unique name. Used as the `destination` override on tool calls. */
+    name: string;
+    /** Human-readable guidance for LLMs/users about when to use this destination. */
+    description?: string;
+    qdrant_url: string;
+    qdrant_api_key: string | null;
+    collection: string;
+    /** Marks this destination as the fallback when no rule matches. */
+    default?: boolean;
+    /** Routing rules. Omit for a destination that is only reachable by override. */
+    match?: DestinationMatch;
+}
+export type SearchScopeTarget = "routed" | "all" | string | string[];
+export interface SearchScopeDefinition {
+    /** Stable scope name that MCP clients can pass as `search_scope`. */
+    name: string;
+    /** Guidance for LLMs/users about when this scope should be used. */
+    description: string;
+    /** Destination selector: "routed", "all", a destination name, or destination names. */
+    destinations: SearchScopeTarget;
+}
 export interface BikkyConfig {
+    /**
+     * Top-level Qdrant fields. When `destinations` is empty, a single default
+     * destination is synthesized from these — keeps single-Qdrant configs
+     * working without changes.
+     */
     qdrant_url: string | null;
     qdrant_api_key: string | null;
     collection: string;
-    default_workspace: string | null;
+    /**
+     * One or more Qdrant routing targets. Memory operations resolve to a
+     * destination via override → cwd/entity/content/metadata regex match →
+     * default flag → first entry.
+     */
+    destinations: Destination[];
+    /**
+     * Default read/search scope. "routed" preserves historical behavior
+     * (one destination via routing rules); "all" fans out to every destination;
+     * a destination name or list searches only those destinations.
+     */
+    default_search_scope: SearchScopeTarget;
+    /** Optional named search scopes exposed to MCP clients with descriptions. */
+    search_scopes: SearchScopeDefinition[];
     aws_profile: string | null;
     embedding: EmbeddingConfig;
     llm: LLMConfig;
@@ -107,6 +163,17 @@ export declare function validateConfigObject(raw: unknown): ConfigIssue[];
 export declare function inspectConfigFile(configPath?: string): ConfigFileDiagnostics;
 export declare function getActiveConfigEnvOverrides(env?: NodeJS.ProcessEnv): string[];
 export declare function loadConfig(): BikkyConfig;
+/**
+ * Resolve the effective list of destinations from the loaded config.
+ *
+ * - If `destinations` is non-empty, return as-is.
+ * - Otherwise synthesize a single fallback destination from the top-level
+ *   `qdrant_url` / `qdrant_api_key` / `collection` so existing single-Qdrant
+ *   configs keep working without changes.
+ * - If neither is configured, returns an empty array — callers should treat
+ *   that as "Qdrant not configured" the same way they did before.
+ */
+export declare function getEffectiveDestinations(config?: BikkyConfig): Destination[];
 /** Save config to disk (used by setup command). */
 export declare function saveConfig(config: BikkyConfig): void;
 /** Reset cached config (for testing). */

package/dist/config.js

@@ -28,7 +28,9 @@ const DEFAULTS = {
     qdrant_url: null,
     qdrant_api_key: null,
     collection: "bikky",
-    default_workspace: null,
+    destinations: [],
+    default_search_scope: "routed",
+    search_scopes: [],
     aws_profile: null,
     embedding: {
         provider: "ollama",
@@ -176,11 +178,38 @@ const identityConfigFileSchema = z.object({
     actor_id: z.string().nullable().optional(),
     actor_label: z.string().nullable().optional(),
 }).passthrough();
+const regexArrayField = z.array(z.string()).optional();
+const destinationMatchSchema = z.object({
+    cwd: regexArrayField,
+    entity: regexArrayField,
+    content: regexArrayField,
+    metadata: z.record(z.array(z.string())).optional(),
+}).passthrough();
+const destinationFileSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    qdrant_url: z.string().min(1),
+    qdrant_api_key: z.string().nullable().optional(),
+    collection: z.string().min(1),
+    default: z.boolean().optional(),
+    match: destinationMatchSchema.optional(),
+}).passthrough();
+const searchScopeTargetSchema = z.union([
+    z.string().min(1),
+    z.array(z.string().min(1)).min(1),
+]);
+const searchScopeDefinitionFileSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    destinations: searchScopeTargetSchema,
+}).passthrough();
 const configFileSchema = z.object({
     qdrant_url: z.string().nullable().optional(),
     qdrant_api_key: z.string().nullable().optional(),
     collection: z.string().optional(),
-    default_workspace: z.string().nullable().optional(),
+    destinations: z.array(destinationFileSchema).optional(),
+    default_search_scope: searchScopeTargetSchema.optional(),
+    search_scopes: z.array(searchScopeDefinitionFileSchema).optional(),
     aws_profile: z.string().nullable().optional(),
     embedding: embeddingConfigFileSchema.optional(),
     llm: llmConfigFileSchema.optional(),
@@ -267,6 +296,144 @@ export function validateConfigObject(raw) {
         });
     }
     validateUrlLike(raw.qdrant_url, "qdrant_url", issues);
+    // Destinations validation
+    if (Array.isArray(raw.destinations)) {
+        const seenNames = new Set();
+        let defaultCount = 0;
+        raw.destinations.forEach((entry, idx) => {
+            const base = `destinations[${idx}]`;
+            if (!isObject(entry)) {
+                issues.push({ severity: "error", path: base, message: "must be an object" });
+                return;
+            }
+            const name = entry.name;
+            if (typeof name === "string" && name.trim() !== "") {
+                if (seenNames.has(name)) {
+                    issues.push({ severity: "error", path: `${base}.name`, message: `duplicate destination name '${name}'` });
+                }
+                seenNames.add(name);
+            }
+            validateUrlLike(entry.qdrant_url, `${base}.qdrant_url`, issues);
+            if (typeof entry.collection === "string" && entry.collection.trim() === "") {
+                issues.push({ severity: "error", path: `${base}.collection`, message: "must not be empty" });
+            }
+            if (entry.default === true)
+                defaultCount++;
+            const match = childObject(entry, "match");
+            if (match) {
+                for (const field of ["cwd", "entity", "content"]) {
+                    const value = match[field];
+                    if (value === undefined)
+                        continue;
+                    if (!Array.isArray(value)) {
+                        issues.push({ severity: "error", path: `${base}.match.${field}`, message: "must be an array of regex strings" });
+                        continue;
+                    }
+                    value.forEach((pattern, pIdx) => {
+                        if (typeof pattern !== "string") {
+                            issues.push({ severity: "error", path: `${base}.match.${field}[${pIdx}]`, message: "must be a string" });
+                            return;
+                        }
+                        try {
+                            new RegExp(pattern);
+                        }
+                        catch (e) {
+                            issues.push({
+                                severity: "error",
+                                path: `${base}.match.${field}[${pIdx}]`,
+                                message: `invalid regex: ${e instanceof Error ? e.message : String(e)}`,
+                            });
+                        }
+                    });
+                }
+                const metadata = childObject(match, "metadata");
+                if (metadata) {
+                    for (const [key, value] of Object.entries(metadata)) {
+                        if (!Array.isArray(value)) {
+                            issues.push({ severity: "error", path: `${base}.match.metadata.${key}`, message: "must be an array of regex strings" });
+                            continue;
+                        }
+                        value.forEach((pattern, pIdx) => {
+                            if (typeof pattern !== "string") {
+                                issues.push({ severity: "error", path: `${base}.match.metadata.${key}[${pIdx}]`, message: "must be a string" });
+                                return;
+                            }
+                            try {
+                                new RegExp(pattern);
+                            }
+                            catch (e) {
+                                issues.push({
+                                    severity: "error",
+                                    path: `${base}.match.metadata.${key}[${pIdx}]`,
+                                    message: `invalid regex: ${e instanceof Error ? e.message : String(e)}`,
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+        });
+        if (defaultCount > 1) {
+            issues.push({ severity: "error", path: "destinations", message: `at most one destination may set 'default: true' (found ${defaultCount})` });
+        }
+    }
+    const destinationNames = new Set();
+    if (Array.isArray(raw.destinations)) {
+        for (const entry of raw.destinations) {
+            if (isObject(entry) && typeof entry.name === "string" && entry.name.trim() !== "") {
+                destinationNames.add(entry.name);
+            }
+        }
+    }
+    const searchScopeNames = new Set();
+    if (Array.isArray(raw.search_scopes)) {
+        for (const entry of raw.search_scopes) {
+            if (isObject(entry) && typeof entry.name === "string" && entry.name.trim() !== "") {
+                searchScopeNames.add(entry.name);
+            }
+        }
+    }
+    const validateSearchScopeTarget = (target, pathName) => {
+        const values = Array.isArray(target) ? target : [target];
+        for (const [idx, value] of values.entries()) {
+            const valuePath = Array.isArray(target) ? `${pathName}[${idx}]` : pathName;
+            if (typeof value !== "string" || value.trim() === "")
+                continue;
+            const normalized = value.trim();
+            if (normalized === "all" || normalized === "routed" || destinationNames.size === 0)
+                continue;
+            if (searchScopeNames.has(normalized))
+                continue;
+            if (!destinationNames.has(normalized)) {
+                issues.push({
+                    severity: "warning",
+                    path: valuePath,
+                    message: `references unknown destination '${normalized}'`,
+                });
+            }
+        }
+    };
+    if (Object.prototype.hasOwnProperty.call(raw, "default_search_scope")) {
+        validateSearchScopeTarget(raw.default_search_scope, "default_search_scope");
+    }
+    if (Array.isArray(raw.search_scopes)) {
+        const seenScopeNames = new Set();
+        raw.search_scopes.forEach((entry, idx) => {
+            const base = `search_scopes[${idx}]`;
+            if (!isObject(entry)) {
+                issues.push({ severity: "error", path: base, message: "must be an object" });
+                return;
+            }
+            const name = entry.name;
+            if (typeof name === "string" && name.trim() !== "") {
+                if (seenScopeNames.has(name)) {
+                    issues.push({ severity: "error", path: `${base}.name`, message: `duplicate search scope name '${name}'` });
+                }
+                seenScopeNames.add(name);
+            }
+            validateSearchScopeTarget(entry.destinations, `${base}.destinations`);
+        });
+    }
     const embedding = childObject(raw, "embedding");
     if (embedding)
         validateUrlLike(embedding.base_url, "embedding.base_url", issues);
@@ -345,8 +512,6 @@ export function loadConfig() {
         config.qdrant_api_key = process.env.QDRANT_API_KEY;
     if (process.env.BIKKY_COLLECTION)
         config.collection = process.env.BIKKY_COLLECTION;
-    if (process.env.BIKKY_DEFAULT_WORKSPACE)
-        config.default_workspace = process.env.BIKKY_DEFAULT_WORKSPACE;
     // Embedding env overrides
     if (process.env.EMBEDDING_PROVIDER)
         config.embedding.provider = process.env.EMBEDDING_PROVIDER;
@@ -481,9 +646,37 @@ export function loadConfig() {
         config.qdrant_url = config.qdrant_url.replace(/\/+$/, "");
     config.embedding.base_url = config.embedding.base_url.replace(/\/+$/, "");
     config.llm.base_url = config.llm.base_url.replace(/\/+$/, "");
+    for (const dest of config.destinations) {
+        if (dest.qdrant_url)
+            dest.qdrant_url = dest.qdrant_url.replace(/\/+$/, "");
+    }
     _config = config;
     return config;
 }
+/**
+ * Resolve the effective list of destinations from the loaded config.
+ *
+ * - If `destinations` is non-empty, return as-is.
+ * - Otherwise synthesize a single fallback destination from the top-level
+ *   `qdrant_url` / `qdrant_api_key` / `collection` so existing single-Qdrant
+ *   configs keep working without changes.
+ * - If neither is configured, returns an empty array — callers should treat
+ *   that as "Qdrant not configured" the same way they did before.
+ */
+export function getEffectiveDestinations(config = loadConfig()) {
+    if (config.destinations.length > 0)
+        return config.destinations;
+    if (!config.qdrant_url)
+        return [];
+    return [{
+            name: "default",
+            description: "Default Qdrant destination synthesized from the top-level qdrant_url, qdrant_api_key, and collection settings.",
+            qdrant_url: config.qdrant_url,
+            qdrant_api_key: config.qdrant_api_key,
+            collection: config.collection,
+            default: true,
+        }];
+}
 /** Save config to disk (used by setup command). */
 export function saveConfig(config) {
     fs.mkdirSync(BIKKY_DIR, { recursive: true });

package/dist/daemon/extraction.d.ts

@@ -1,12 +1,14 @@
 /**
- * Events-based memory extraction — reads Copilot CLI events.jsonl transcripts,
+ * Events-based memory extraction — reads supported coding-agent transcripts,
  * extracts facts via LLM, and stores them in Qdrant with source: "system".
  *
  * Uses a JSON file for extraction state (high-water byte offsets) instead of SQLite.
- * Active session detection scans ~/.copilot/session-state/ for lock files.
+ * Copilot session detection uses lock files. Claude Code detection uses
+ * top-level JSONL transcripts under ~/.claude/projects.
  */
 import type { BikkyConfig } from "../config.js";
 import type { LogFn } from "./qdrant.js";
+import { type TranscriptSource } from "./transcript-sources.js";
 export declare const setLogger: (fn: LogFn) => void;
 export declare const DEFAULT_EXTRACTION_PROMPT = "You are Bikky's memory extraction agent for open-source coding agents. Extract durable, reusable facts that help a future agent continue work without rereading the whole transcript.\n\n## Core rule\nExtract fewer, sharper memories. A candidate fact must be independently useful after the session is gone.\n\n## Quality gate\nEvery fact must pass at least one gate:\n1. GREPPABLE: names a file path, package, symbol, config key, CLI flag, issue/PR, service, or API a future agent can search for.\n2. RUNNABLE: contains a command, URL, setting, port, or procedure that can be executed or checked.\n3. NAVIGABLE: tells a future agent where to look and what that location means.\n4. DECISIVE: records a durable decision, rationale, constraint, convention, or preference.\n5. DIAGNOSTIC: captures a repeatable failure mode, root cause, or troubleshooting gotcha.\n\n## Ontology\n- domain is the activity profile. For coding-agent captures use \"software_engineering\".\n- category is subject matter: engineering | product | human | system.\n- kind is object shape. For this prompt, emit only kind=\"fact\".\n- memory_subtype must be one of:\n  codebase_map | architecture_decision | infra_topology | access_pattern | operational_procedure | domain_rule | product_decision | product_requirement | user_workflow | roadmap_item | success_metric | market_insight | troubleshooting_gotcha | preference | person_profile | ownership_note | working_agreement | activity_event.\n\n## Examples\nGOOD:\n- \"The UI smoke tests live in packages/ui/tests/smoke.spec.ts and run through npm run test:e2e with mocked /api/memory/* responses.\"\n- \"Use workspace_id as the tenancy/access boundary; domain is reserved for activity profile such as software_engineering.\"\n- \"If Qdrant order_by fails with a missing index error, create a datetime payload index for the sorted field before retrying.\"\n- \"The memory page should show categories and concrete subtype chips directly; a sub-tab layer makes the ontology harder to understand.\"\n- \"Saber prefers Node's built-in test runner for root tests; do not add Jest just for daemon unit tests.\"\n- \"Saber merged PR #85 after approving the subtype UX copy changes.\"\n\nBAD:\n- \"The tests were fixed.\" (status only)\n- \"We reviewed the code.\" (session narration)\n- \"The deployment succeeded.\" (transient and not reusable)\n- \"The agent used npm.\" (tool narration)\n- \"There was an error.\" (no root cause or reusable detail)\n\n## Output format\nReturn strict JSON:\n{\"facts\":[\n  {\n    \"content\":\"One self-contained durable fact.\",\n    \"category\":\"engineering\",\n    \"memory_subtype\":\"codebase_map\",\n    \"action_actor\":\"optional actor for activity_event only\",\n    \"action_type\":\"optional action verb for activity_event only\",\n    \"action_object\":\"optional durable object for activity_event only\",\n    \"action_outcome\":\"optional durable outcome for activity_event only\",\n    \"entities\":[\"repo-or-tool\",\"specific-module\"],\n    \"confidence\":0.9,\n    \"importance\":0.7,\n    \"quality_score\":0.8,\n    \"confidence_reason\":\"Explicitly stated in the transcript.\",\n    \"repo\":\"optional/repo-or-package\",\n    \"branch\":\"optional-branch\",\n    \"task_key\":\"optional issue/PR/task key\",\n    \"workstream_key\":\"optional stable workstream key\"\n  }\n]}\n\nScoring:\n- confidence: 0.9 explicit, 0.7 strong inference, 0.55 weak but useful inference.\n- importance: 0.8+ for decisions, infra, procedures, access, recurring failures, product requirements, ownership, and state-changing activity events; 0.6+ for useful codebase maps/preferences.\n- quality_score: 0.8+ passes multiple gates, 0.6+ passes one strong gate, below 0.6 should usually be omitted.\n\nIf nothing passes the quality gate, return {\"facts\":[]}.";
 export type Volatility = "stable" | "evolving" | "transient" | "ephemeral";
@@ -60,5 +62,13 @@ export interface ExtractionHealth {
     active_session_count: number;
     /** Configured copilot watcher path at the time of the tick. */
     watcher_path: string;
+    /** Per-source health, including non-Copilot watchers. */
+    sources?: Record<TranscriptSource, ExtractionSourceHealth>;
+}
+export interface ExtractionSourceHealth {
+    enabled: boolean;
+    watcher_path: string;
+    active_session_count: number;
+    last_active_session_at: string | null;
 }
 //# sourceMappingURL=extraction.d.ts.map