bikky 0.3.13 → 0.4.1

package/dist/daemon/watcher.js

@@ -1,6 +1,5 @@
 /**
- * Copilot session watcher — detects active sessions by scanning
- * ~/.copilot/session-state/ for directories with events.jsonl files.
+ * Session watcher helpers for supported coding-agent transcript directories.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -31,8 +30,58 @@ export function discoverSessions() {
             uuid: entry,
             eventsPath,
             active: lockFiles.length > 0,
+            source: "copilot",
         });
     }
     return sessions;
 }
+export function discoverClaudeSessions() {
+    const cfg = loadConfig();
+    if (!cfg.watchers.claude.enabled)
+        return [];
+    const baseDir = cfg.watchers.claude.path;
+    if (!fs.existsSync(baseDir))
+        return [];
+    const sessions = [];
+    for (const entry of fs.readdirSync(baseDir)) {
+        const projectPath = path.join(baseDir, entry);
+        let stat;
+        try {
+            stat = fs.statSync(projectPath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isFile() && entry.endsWith(".jsonl")) {
+            sessions.push({
+                uuid: path.basename(entry, ".jsonl"),
+                eventsPath: projectPath,
+                active: true,
+                source: "claude",
+            });
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        for (const file of fs.readdirSync(projectPath)) {
+            const transcriptPath = path.join(projectPath, file);
+            let transcriptStat;
+            try {
+                transcriptStat = fs.statSync(transcriptPath);
+            }
+            catch {
+                continue;
+            }
+            if (!transcriptStat.isFile() || !file.endsWith(".jsonl"))
+                continue;
+            sessions.push({
+                uuid: path.basename(file, ".jsonl"),
+                eventsPath: transcriptPath,
+                active: true,
+                source: "claude",
+            });
+        }
+    }
+    return sessions;
+}
 //# sourceMappingURL=watcher.js.map

package/dist/install.d.ts

@@ -1,5 +1,13 @@
 /**
  * Write MCP config entries for Copilot and/or Claude Code.
  */
-export declare function writeInstallConfig(): Promise<void>;
+export interface InstallOptions {
+    homeDir?: string;
+    /**
+     * Defaults to `claude`. Set to null to skip the Claude Code CLI and write the
+     * user config file directly.
+     */
+    claudeCommand?: string | null;
+}
+export declare function writeInstallConfig(options?: InstallOptions): Promise<void>;
 //# sourceMappingURL=install.d.ts.map

package/dist/install.js

@@ -4,46 +4,74 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-export async function writeInstallConfig() {
+import { spawnSync } from "node:child_process";
+const SERVER_NAME = "bikky";
+function readJsonConfig(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJsonConfig(filePath, config) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n");
+}
+function writeCopilotConfig(homeDir, entry) {
+    const copilotConfigPath = path.join(homeDir, ".copilot", "mcp-config.json");
+    const config = readJsonConfig(copilotConfigPath);
+    config.mcpServers ??= {};
+    config.mcpServers[SERVER_NAME] = entry;
+    writeJsonConfig(copilotConfigPath, config);
+    console.log(`✅ Written to ${copilotConfigPath}`);
+}
+function registerClaudeWithCli(homeDir, entry, command) {
+    const result = spawnSync(command, ["mcp", "add-json", "-s", "user", SERVER_NAME, JSON.stringify(entry)], {
+        env: { ...process.env, HOME: homeDir },
+        encoding: "utf-8",
+        stdio: "pipe",
+    });
+    if (result.status === 0) {
+        console.log(`✅ Registered ${SERVER_NAME} with Claude Code user config`);
+        return true;
+    }
+    if (result.error && "code" in result.error && result.error.code === "ENOENT") {
+        return false;
+    }
+    const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+    if (/already exists/i.test(stderr)) {
+        return false;
+    }
+    const detail = stderr ? `: ${stderr}` : "";
+    console.warn(`⚠️  Claude Code CLI registration failed${detail}`);
+    return false;
+}
+function writeClaudeCodeUserConfig(homeDir, entry) {
+    const claudeConfigPath = path.join(homeDir, ".claude.json");
+    const config = readJsonConfig(claudeConfigPath);
+    config.mcpServers ??= {};
+    config.mcpServers[SERVER_NAME] = entry;
+    writeJsonConfig(claudeConfigPath, config);
+    console.log(`✅ Written to ${claudeConfigPath}`);
+}
+export async function writeInstallConfig(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
     const entry = {
         type: "stdio",
         command: "npx",
         args: ["-y", "bikky", "mcp"],
     };
-    // Copilot MCP config
-    const copilotConfigPath = path.join(os.homedir(), ".copilot", "mcp-config.json");
-    let config = {};
-    if (fs.existsSync(copilotConfigPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(copilotConfigPath, "utf-8"));
-        }
-        catch {
-            config = {};
-        }
+    writeCopilotConfig(homeDir, entry);
+    const claudeCommand = options.claudeCommand === undefined ? "claude" : options.claudeCommand;
+    const registeredWithClaudeCli = claudeCommand
+        ? registerClaudeWithCli(homeDir, entry, claudeCommand)
+        : false;
+    if (!registeredWithClaudeCli) {
+        writeClaudeCodeUserConfig(homeDir, entry);
     }
-    if (!config.mcpServers)
-        config.mcpServers = {};
-    config.mcpServers["bikky"] = entry;
-    fs.mkdirSync(path.dirname(copilotConfigPath), { recursive: true });
-    fs.writeFileSync(copilotConfigPath, JSON.stringify(config, null, 2) + "\n");
-    console.log(`✅ Written to ${copilotConfigPath}`);
-    // Claude Code MCP config
-    const claudeConfigPath = path.join(os.homedir(), ".claude", "mcp.json");
-    let claudeConfig = {};
-    if (fs.existsSync(claudeConfigPath)) {
-        try {
-            claudeConfig = JSON.parse(fs.readFileSync(claudeConfigPath, "utf-8"));
-        }
-        catch {
-            claudeConfig = {};
-        }
-    }
-    if (!claudeConfig.mcpServers)
-        claudeConfig.mcpServers = {};
-    claudeConfig.mcpServers["bikky"] = entry;
-    fs.mkdirSync(path.dirname(claudeConfigPath), { recursive: true });
-    fs.writeFileSync(claudeConfigPath, JSON.stringify(claudeConfig, null, 2) + "\n");
-    console.log(`✅ Written to ${claudeConfigPath}`);
     console.log("\n🧠 bikky is now registered. Restart your editor to activate.");
 }
 //# sourceMappingURL=install.js.map

package/dist/lib/qdrant-pool.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Per-destination Qdrant client cache.
+ *
+ * Multi-destination bikky may talk to several Qdrant Cloud accounts (or
+ * collections) in parallel. We keep one `QdrantClient` per destination keyed
+ * by `destination.name`, lazily constructed on first use.
+ *
+ * The cache also tracks per-destination `collectionReady` so the daemon can
+ * keep retrying `ensureCollection` for destinations whose collection failed
+ * to materialize at startup, without blocking other destinations.
+ */
+import type { Destination, QdrantClientConfig } from "../config.js";
+import { QdrantClient, type QdrantLogFn } from "./qdrant-client.js";
+export interface PoolOptions {
+    client: QdrantClientConfig;
+    log?: QdrantLogFn;
+}
+export declare class QdrantPool {
+    private readonly entries;
+    private readonly options;
+    constructor(destinations: ReadonlyArray<Destination>, options: PoolOptions);
+    /** Returns the names of all destinations in the pool, in registration order. */
+    names(): string[];
+    /** All Destination objects currently registered. */
+    destinations(): Destination[];
+    /** Get the QdrantClient for a destination by name. Throws if unknown. */
+    client(name: string): QdrantClient;
+    /** Get the collection name for a destination. */
+    collection(name: string): string;
+    /** Whether the destination's collection has been confirmed ready. */
+    isCollectionReady(name: string): boolean;
+    /** Last error observed for a destination, or null. */
+    lastError(name: string): string | null;
+    /**
+     * Run `ensureCollection` for a single destination. Updates the pool's
+     * readiness flag and last-error state. Re-throws on failure so the caller
+     * can decide whether to retry, log, or skip.
+     */
+    ensureCollection(name: string, vectorSize: number, indexes: Array<{
+        field_name: string;
+        field_schema: string;
+    }>): Promise<void>;
+    /**
+     * Run a callback against every destination's client, in parallel. Errors
+     * from one destination do not prevent others from running. Returns the per-
+     * destination result (or error) so callers can act on the outcome.
+     */
+    fanOut<T>(fn: (destination: Destination, client: QdrantClient) => Promise<T>): Promise<Array<{
+        destination: Destination;
+        result: T | null;
+        error: Error | null;
+    }>>;
+    /** Replace the entire pool with a new destination set. Existing clients are dropped. */
+    rebuild(destinations: ReadonlyArray<Destination>): void;
+    private upsertEntry;
+}
+//# sourceMappingURL=qdrant-pool.d.ts.map

package/dist/lib/qdrant-pool.js

@@ -0,0 +1,104 @@
+import { QdrantClient } from "./qdrant-client.js";
+export class QdrantPool {
+    entries = new Map();
+    options;
+    constructor(destinations, options) {
+        this.options = options;
+        for (const destination of destinations) {
+            this.upsertEntry(destination);
+        }
+    }
+    /** Returns the names of all destinations in the pool, in registration order. */
+    names() {
+        return [...this.entries.keys()];
+    }
+    /** All Destination objects currently registered. */
+    destinations() {
+        return [...this.entries.values()].map((e) => e.destination);
+    }
+    /** Get the QdrantClient for a destination by name. Throws if unknown. */
+    client(name) {
+        const entry = this.entries.get(name);
+        if (!entry) {
+            throw new Error(`Destination '${name}' is not in the pool. Known: ${this.names().join(", ") || "(none)"}`);
+        }
+        return entry.client;
+    }
+    /** Get the collection name for a destination. */
+    collection(name) {
+        const entry = this.entries.get(name);
+        if (!entry)
+            throw new Error(`Destination '${name}' is not in the pool.`);
+        return entry.destination.collection;
+    }
+    /** Whether the destination's collection has been confirmed ready. */
+    isCollectionReady(name) {
+        return this.entries.get(name)?.collectionReady === true;
+    }
+    /** Last error observed for a destination, or null. */
+    lastError(name) {
+        return this.entries.get(name)?.lastError ?? null;
+    }
+    /**
+     * Run `ensureCollection` for a single destination. Updates the pool's
+     * readiness flag and last-error state. Re-throws on failure so the caller
+     * can decide whether to retry, log, or skip.
+     */
+    async ensureCollection(name, vectorSize, indexes) {
+        const entry = this.entries.get(name);
+        if (!entry)
+            throw new Error(`Destination '${name}' is not in the pool.`);
+        try {
+            await entry.client.ensureCollection(vectorSize, indexes);
+            entry.collectionReady = true;
+            entry.lastError = null;
+        }
+        catch (e) {
+            entry.collectionReady = false;
+            entry.lastError = e instanceof Error ? e.message : String(e);
+            throw e;
+        }
+    }
+    /**
+     * Run a callback against every destination's client, in parallel. Errors
+     * from one destination do not prevent others from running. Returns the per-
+     * destination result (or error) so callers can act on the outcome.
+     */
+    async fanOut(fn) {
+        const promises = [...this.entries.values()].map(async (entry) => {
+            try {
+                const result = await fn(entry.destination, entry.client);
+                return { destination: entry.destination, result, error: null };
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                return { destination: entry.destination, result: null, error: err };
+            }
+        });
+        return Promise.all(promises);
+    }
+    /** Replace the entire pool with a new destination set. Existing clients are dropped. */
+    rebuild(destinations) {
+        this.entries.clear();
+        for (const destination of destinations)
+            this.upsertEntry(destination);
+    }
+    upsertEntry(destination) {
+        const client = new QdrantClient({
+            url: destination.qdrant_url,
+            apiKey: destination.qdrant_api_key,
+            collection: destination.collection,
+            timeoutMs: this.options.client.timeout_ms,
+            retries: this.options.client.retries,
+            retryBaseDelayMs: this.options.client.retry_base_delay_ms,
+            log: this.options.log,
+        });
+        this.entries.set(destination.name, {
+            destination,
+            client,
+            collectionReady: false,
+            lastError: null,
+        });
+    }
+}
+//# sourceMappingURL=qdrant-pool.js.map

package/dist/mcp/api.d.ts

@@ -1,17 +1,25 @@
 /**
- * External API helpers — Qdrant REST client, LLM chat, logging.
- * Credentials come from config (~/.bikky/config.json) or env vars.
+ * External API helpers — Qdrant REST client pool, LLM chat, logging.
+ *
+ * Multi-destination model: write operations resolve to one Destination
+ * (see ../routing.ts) and operate against that destination's QdrantClient
+ * via the QdrantPool (see ../lib/qdrant-pool.ts). Read/search operations may
+ * resolve a search scope and fan out across multiple destinations.
+ *
+ * The legacy single-Qdrant API is kept around for back-compat where call sites
+ * have not yet been refactored — they all route to a "default" destination
+ * synthesized from the top-level qdrant_url/qdrant_api_key/collection.
  */
 import type { QdrantFilter, QdrantGetResult, QdrantScrollResult, QdrantSearchResult } from "./types.js";
 import { embed, getEmbeddingDimensions, getEmbeddingConfig, initEmbedding } from "../llm/index.js";
 import type { ChatCompletionOpts } from "../llm/index.js";
 export type { ResolvedEmbeddingConfig } from "../llm/index.js";
 export { embed, getEmbeddingDimensions, getEmbeddingConfig, initEmbedding };
+import { type Destination } from "../config.js";
+import { QdrantPool } from "../lib/qdrant-pool.js";
+import { type RoutingInput } from "../routing.js";
 export declare const MEMORY_DIR: string;
-export declare function getCollection(): string;
-export declare function setCollection(name: string): void;
-export declare let qdrantUrl: string | null;
-export declare let qdrantApiKey: string | null;
+export declare const log: import("../logger.js").LogFn;
 export declare let ready: boolean;
 /**
  * Reason the system is not ready, when known. Set by `setSetupError` from the
@@ -20,25 +28,55 @@ export declare let ready: boolean;
  * instead of a generic "setup_required".
  */
 export declare let setupError: string | null;
-export declare function setQdrantUrl(v: string | null): void;
-export declare function setQdrantApiKey(v: string | null): void;
 export declare function setReady(v: boolean): void;
 export declare function setSetupError(v: string | null): void;
-export declare const log: import("../logger.js").LogFn;
-export declare function chatComplete(systemPrompt: string, userPrompt: string): Promise<string>;
 /**
- * Run a pre-rendered prompt (from src/prompts/*) through the LLM. The
- * RenderedPrompt already carries messages, response_format, temperature, etc.
+ * (Re)build the destination pool from the current config. Idempotent — safe
+ * to call after configure_credentials updates the on-disk config.
  */
+export declare function rebuildPool(): void;
+export declare function getPool(): QdrantPool;
+/** Whether at least one destination is configured. */
+export declare function hasPool(): boolean;
+/** All destination names currently in the pool, in registration order. */
+export declare function destinationNames(): string[];
+/** All Destination objects in the pool. */
+export declare function listDestinations(): Destination[];
+/** True if any destination's collection is confirmed ready. */
+export declare function anyCollectionReady(): boolean;
+/** Resolve a destination from caller input. Throws if not configured/found. */
+export declare function resolveDest(input: RoutingInput): Destination;
+/** Build a resolver closure from the current pool's destinations. */
+export declare function makeResolver(): (input: RoutingInput) => Destination;
+export declare function chatComplete(systemPrompt: string, userPrompt: string): Promise<string>;
 export declare function chatCompleteRendered(opts: ChatCompletionOpts): Promise<string>;
-export declare function qdrantReq<T>(method: string, urlPath: string, body?: unknown): Promise<T>;
-export declare function ensureCollection(indexes: Array<{
+export declare function qdrantReq<T>(destination: Destination, method: string, urlPath: string, body?: unknown): Promise<T>;
+export declare function ensureCollection(destination: Destination, indexes: Array<{
     field_name: string;
     field_schema: string;
 }>): Promise<void>;
-export declare function qdrantUpsert(id: string, vector: number[], payload: Record<string, unknown>): Promise<unknown>;
-export declare function qdrantSearch(vector: number[], filter: QdrantFilter | undefined, limit?: number): Promise<QdrantSearchResult>;
-export declare function qdrantScroll(filter: QdrantFilter, limit?: number): Promise<QdrantScrollResult>;
-export declare function qdrantSetPayload(ids: string[], payload: Record<string, unknown>): Promise<unknown>;
-export declare function qdrantGetPoints(ids: string[]): Promise<QdrantGetResult>;
+/** Run ensureCollection for every destination in the pool. Failures don't stop the loop. */
+export declare function ensureCollectionsAll(indexes: Array<{
+    field_name: string;
+    field_schema: string;
+}>): Promise<Array<{
+    destination: Destination;
+    ok: boolean;
+    error: string | null;
+}>>;
+export declare function qdrantUpsert(destination: Destination, id: string, vector: number[], payload: Record<string, unknown>): Promise<unknown>;
+export declare function qdrantSearch(destination: Destination, vector: number[], filter: QdrantFilter | undefined, limit?: number): Promise<QdrantSearchResult>;
+export declare function qdrantScroll(destination: Destination, filter: QdrantFilter, limit?: number): Promise<QdrantScrollResult>;
+export declare function qdrantSetPayload(destination: Destination, ids: string[], payload: Record<string, unknown>): Promise<unknown>;
+export declare function qdrantGetPoints(destination: Destination, ids: string[]): Promise<QdrantGetResult>;
+/**
+ * Look up a point by ID across every destination. Returns the first hit found
+ * (and which destination it lives in), or null. Used by `memory_forget`,
+ * `memory_verify`, `memory_report_outcome`, and any other ID-based op where
+ * the caller doesn't know upfront which destination owns the ID.
+ */
+export declare function findPointById(id: string): Promise<{
+    destination: Destination;
+    point: NonNullable<QdrantGetResult["result"]>[number];
+} | null>;
 //# sourceMappingURL=api.d.ts.map