@ganziliang/kb 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, render, useApp, useInput } from "ink";
+import { mkdirSync } from "node:fs";
+import { ensureModelConfig, saveModels } from "./config.js";
+import { Agent, fetchTransport } from "./model.js";
+import { copyOriginal, defaultDataRoot, ensureKnowledgeBase, KnowledgeStore, readLocalFile, listKnowledgeBases, deleteKnowledgeBase, backupKnowledgeBase, restoreKnowledgeBase } from "./storage.js";
+function App({ config, root, knowledgeBase }) {
+    const { exit } = useApp();
+    const [input, setInput] = useState("");
+    const [lines, setLines] = useState(["Local Knowledge Agent", `knowledge base: ${knowledgeBase.name}`, "Type a question, or /help."]);
+    const [busy, setBusy] = useState(false);
+    const [messages, setMessages] = useState([]);
+    const [modelIndex, setModelIndex] = useState(0);
+    const [currentBase, setCurrentBase] = useState(knowledgeBase);
+    const storeRef = useRef(new KnowledgeStore(knowledgeBase.path));
+    const store = storeRef.current;
+    useEffect(() => () => storeRef.current.close(), []);
+    useInput((char, key) => {
+        if (key.ctrl && char === "c") {
+            store.close();
+            exit();
+            return;
+        }
+        if (key.return && input.trim() && !busy) {
+            void submit(input.trim());
+            setInput("");
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setInput((value) => value.slice(0, -1));
+            return;
+        }
+        if (!key.ctrl && !key.meta && char)
+            setInput((value) => value + char);
+    });
+    async function submit(value) {
+        if (value === "/quit" || value === "/exit") {
+            store.close();
+            exit();
+            return;
+        }
+        if (value === "/clear") {
+            setLines(["Conversation cleared."]);
+            setMessages([]);
+            return;
+        }
+        if (value === "/help") {
+            setLines((old) => [...old, "/help /clear /sources /backup /restore /cleanup /model /models /kb /quit"]);
+            return;
+        }
+        if (value === "/sources") {
+            setLines((old) => [...old, ...store.sources().map((s) => `${s.name} | ${s.path} | v${s.version} | ${s.updatedAt}`)]);
+            return;
+        }
+        if (value === "/model" || value === "/models") {
+            setLines((old) => [...old, ...config.map((item, i) => `${i === modelIndex ? "*" : " "} ${i}: ${item.provider}/${item.model} (${item.api})`)]);
+            return;
+        }
+        if (value.startsWith("/model ")) {
+            const index = Number(value.slice(7));
+            if (config[index]) {
+                setModelIndex(index);
+                saveModels([config[index], ...config.filter((_, i) => i !== index)]);
+                setLines((old) => [...old, `Using ${config[index].model}`]);
+            }
+            else
+                setLines((old) => [...old, "Unknown model index."]);
+            return;
+        }
+        if (value.startsWith("/kb ")) {
+            const [command, ...args] = value.slice(4).trim().split(/\s+/);
+            if (command === "list") {
+                setLines((old) => [...old, ...listKnowledgeBases(root).map((item) => `${item.id}${item.id === currentBase.id ? " *" : ""}`)]);
+                return;
+            }
+            if (command === "current") {
+                setLines((old) => [...old, `${currentBase.name} (${currentBase.id})`]);
+                return;
+            }
+            if (command === "create" && args.length) {
+                const created = ensureKnowledgeBase(root, args.join(" "));
+                setLines((old) => [...old, `Created ${created.name} (${created.id})`]);
+                return;
+            }
+            if (command === "use" && args[0]) {
+                const selected = listKnowledgeBases(root).find((item) => item.id === args[0] || item.name === args.join(" "));
+                if (!selected) {
+                    setLines((old) => [...old, "Knowledge base not found."]);
+                    return;
+                }
+                store.close();
+                storeRef.current = new KnowledgeStore(selected.path);
+                setCurrentBase(selected);
+                setMessages([]);
+                setLines((old) => [...old, `Using ${selected.name}`]);
+                return;
+            }
+            if (command === "delete" && args[0] && args[1] === "confirm") {
+                deleteKnowledgeBase(root, args[0]);
+                setLines((old) => [...old, `Deleted ${args[0]}; backups were retained.`]);
+                return;
+            }
+            setLines((old) => [...old, "Usage: /kb list | /kb create <name> | /kb use <id> | /kb current | /kb delete <id> confirm"]);
+            return;
+        }
+        if (value === "/backup" || value.startsWith("/backup ")) {
+            setLines((old) => [...old, `Backup created at ${backupKnowledgeBase(currentBase, value.slice(7).trim() || undefined)}`]);
+            return;
+        }
+        if (value.startsWith("/restore ")) {
+            restoreKnowledgeBase(currentBase, value.slice(9).trim());
+            setLines((old) => [...old, "Knowledge base restored. Restart the session to reopen the database."]);
+            return;
+        }
+        if (value === "/cleanup") {
+            const oldVersions = store.oldVersions();
+            setLines((old) => [...old, oldVersions.length ? `Old versions (delete with /cleanup <id> confirm): ${oldVersions.map((item) => `${item.id} ${item.title} v${item.version}`).join("; ")}` : "No old versions."]);
+            return;
+        }
+        if (value.startsWith("/cleanup ")) {
+            const [id, confirmation] = value.slice(9).trim().split(/\s+/);
+            if (confirmation === "confirm") {
+                store.removeVersions([id]);
+                setLines((old) => [...old, `Deleted old version ${id}.`]);
+            }
+            else
+                setLines((old) => [...old, "Usage: /cleanup <version-id> confirm"]);
+            return;
+        }
+        setBusy(true);
+        setLines((old) => [...old, `> ${value}`]);
+        try {
+            const result = await ingestOrAsk(value, store, config[modelIndex], messages);
+            setMessages(result.messages);
+            store.saveMessage("user", value);
+            store.saveMessage("assistant", result.text);
+            setLines((old) => [...old, result.text]);
+        }
+        catch (error) {
+            setLines((old) => [...old, `Error: ${error instanceof Error ? error.message : String(error)}`]);
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    return _jsxs(Box, { flexDirection: "column", padding: 1, children: [lines.slice(-18).map((line, i) => _jsx(Text, { children: line }, `${i}-${line}`)), _jsxs(Text, { color: busy ? "yellow" : "cyan", children: [busy ? "Searching..." : "> ", input] })] });
+}
+async function ingestOrAsk(value, store, modelConfig, previous) {
+    const pathMatch = value.match(/(?:录入|导入|整理|ingest|import)\s+(.+)$/i);
+    if (pathMatch) {
+        const source = readLocalFile(pathMatch[1].trim().replace(/^['"]|['"]$/g, ""));
+        if (!source.hash)
+            return { text: `${source.title}: unable to parse (${source.content})`, messages: previous };
+        const copied = copyOriginal(source.originalPath, store.root);
+        const result = store.addOrUpdateSource(copied, source.title, source.content);
+        return { text: `${result.isNew ? "Imported" : "New version created for"} ${result.title} (v${result.version})`, messages: previous };
+    }
+    const results = store.search(value);
+    const context = results.length ? results.map((item) => `[${item.id}] ${item.title} (source: ${item.source}, v${item.version})\n${item.content}`).join("\n\n") : "No matching knowledge was found.";
+    const agent = new Agent(store, modelConfig, fetchTransport);
+    return agent.answer(`Answer only from the local knowledge below. If it is insufficient, say no knowledge was found. Include source filename and version.\n\n${context}\n\nQuestion: ${value}`, previous);
+}
+async function main() {
+    const root = defaultDataRoot();
+    mkdirSync(root, { recursive: true });
+    const knowledgeRoot = root;
+    const base = ensureKnowledgeBase(root, "default");
+    const configs = await ensureModelConfig();
+    render(_jsx(App, { config: configs, root: knowledgeRoot, knowledgeBase: base }));
+}
+void main();

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import { type ModelConfig } from "@ganziliang/kb-model-setup";
+export declare function configPath(): string;
+export declare function loadModels(): ModelConfig[];
+export declare function saveModels(models: ModelConfig[]): void;
+export declare function ensureModelConfig(): Promise<ModelConfig[]>;

package/dist/config.js

@@ -0,0 +1,46 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import * as readline from "node:readline/promises";
+import { configFromEnvironment, createModelSetupExtension } from "@ganziliang/kb-model-setup";
+export function configPath() {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? process.cwd();
+    return process.env.KB_CONFIG_FILE ?? join(home, ".config", "kb", "config.json");
+}
+export function loadModels() {
+    try {
+        return JSON.parse(readFileSync(configPath(), "utf8")).models ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+export function saveModels(models) {
+    mkdirSync(dirname(configPath()), { recursive: true });
+    writeFileSync(configPath(), JSON.stringify({ models, activeModel: models[0]?.model }, null, 2));
+}
+function readlinePrompter() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return {
+        close: () => rl.close(),
+        ask: (question, initial) => rl.question(`${question}${initial ? ` [${initial}]` : ""}: `).then((value) => value || initial || ""),
+        select: async (question, choices, initial = 0) => { console.log(choices.map((choice, i) => `${i === initial ? "*" : " "} ${i}: ${choice}`).join("\n")); const value = await rl.question(`${question} [${initial}]: `); return Number.isFinite(Number(value)) ? Number(value) : initial; },
+        confirm: (question) => rl.question(`${question} [y/N]: `).then((value) => /^y(es)?$/i.test(value)),
+        notice: async (message) => { console.log(message); },
+    };
+}
+export async function ensureModelConfig() {
+    const envConfig = configFromEnvironment();
+    if (envConfig) {
+        saveModels([envConfig]);
+        return [envConfig];
+    }
+    const models = loadModels();
+    if (models.length)
+        return models;
+    const extension = createModelSetupExtension();
+    const prompter = readlinePrompter();
+    const config = await extension.configure(prompter);
+    prompter.close?.();
+    saveModels([config]);
+    return [config];
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./storage.js";
+export * from "./model.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./storage.js";
+export * from "./model.js";

package/dist/model.d.ts

@@ -0,0 +1,31 @@
+import type { ModelConfig } from "@ganziliang/kb-model-setup";
+import type { SearchResult, KnowledgeStore } from "./storage.js";
+export type ToolCall = {
+    name: "search" | "read" | "write";
+    arguments: Record<string, unknown>;
+};
+export type ModelMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCallId?: string;
+};
+export type ModelReply = {
+    text?: string;
+    toolCalls?: ToolCall[];
+};
+export type ModelTransport = {
+    complete(config: ModelConfig, messages: ModelMessage[]): Promise<ModelReply>;
+};
+export declare const fetchTransport: ModelTransport;
+export declare class Agent {
+    private readonly store;
+    private readonly config;
+    private readonly transport;
+    constructor(store: KnowledgeStore, config: ModelConfig, transport?: ModelTransport);
+    answer(question: string, previous?: ModelMessage[]): Promise<{
+        text: string;
+        messages: ModelMessage[];
+    }>;
+    private execute;
+}
+export declare function formatResults(results: SearchResult[]): string;

package/dist/model.js

@@ -0,0 +1,59 @@
+function endpoint(config) {
+    return `${config.baseURL.replace(/\/$/, "")}${config.api === "anthropic-messages" ? "/v1/messages" : "/v1/responses"}`;
+}
+export const fetchTransport = {
+    async complete(config, messages) {
+        const headers = { "content-type": "application/json" };
+        if (config.api === "anthropic-messages") {
+            headers["x-api-key"] = config.apiKey;
+            headers["anthropic-version"] = "2023-06-01";
+        }
+        else
+            headers.authorization = `Bearer ${config.apiKey}`;
+        const response = await fetch(endpoint(config), {
+            method: "POST",
+            headers,
+            body: JSON.stringify(config.api === "anthropic-messages"
+                ? { model: config.model, max_tokens: 4096, messages: messages.filter((m) => m.role !== "system"), system: messages.find((m) => m.role === "system")?.content }
+                : { model: config.model, input: messages.map((m) => ({ role: m.role, content: m.content })) }),
+        });
+        if (!response.ok)
+            throw new Error(`Model request failed (${response.status}): ${await response.text()}`);
+        const data = await response.json();
+        if (config.api === "anthropic-messages")
+            return { text: data.content?.map((item) => item.text ?? "").join("") };
+        return { text: data.output_text ?? data.output?.map((item) => item.content?.map((part) => part.text ?? "").join("")).join("") ?? "" };
+    },
+};
+export class Agent {
+    store;
+    config;
+    transport;
+    constructor(store, config, transport = fetchTransport) {
+        this.store = store;
+        this.config = config;
+        this.transport = transport;
+    }
+    async answer(question, previous = []) {
+        const messages = [...previous, { role: "user", content: question }];
+        const first = await this.transport.complete(this.config, messages);
+        if (!first.toolCalls?.length)
+            return { text: first.text ?? "", messages: [...messages, { role: "assistant", content: first.text ?? "" }] };
+        for (const call of first.toolCalls) {
+            const result = this.execute(call);
+            messages.push({ role: "tool", content: JSON.stringify(result), toolCallId: call.name });
+        }
+        const final = await this.transport.complete(this.config, messages);
+        return { text: final.text ?? "", messages: [...messages, { role: "assistant", content: final.text ?? "" }] };
+    }
+    execute(call) {
+        if (call.name === "search")
+            return this.store.search(String(call.arguments.query ?? ""));
+        if (call.name === "read")
+            return this.store.read(String(call.arguments.id ?? "")) ?? { error: "Knowledge record not found" };
+        return { error: "write requires CLI ingestion flow" };
+    }
+}
+export function formatResults(results) {
+    return results.map((result) => `[${result.id}] ${result.title} (source: ${result.source}, v${result.version})\n${result.content}`).join("\n\n");
+}

package/dist/storage.d.ts

@@ -0,0 +1,54 @@
+import { DatabaseSync } from "node:sqlite";
+export type KnowledgeBase = {
+    id: string;
+    name: string;
+    path: string;
+};
+export type SearchResult = {
+    id: string;
+    title: string;
+    content: string;
+    source: string;
+    version: number;
+    updatedAt: string;
+};
+export declare function tokenize(text: string): string;
+export declare class KnowledgeStore {
+    readonly root: string;
+    readonly db: DatabaseSync;
+    constructor(root: string);
+    close(): void;
+    addOrUpdateSource(filePath: string, title: string, content: string): KnowledgeStoreResult;
+    search(query: string, limit?: number): SearchResult[];
+    read(id: string): SearchResult | undefined;
+    sources(): Array<Record<string, unknown>>;
+    oldVersions(): Array<Record<string, unknown>>;
+    removeVersions(ids: string[]): void;
+    saveMessage(role: string, content: string): void;
+    listMessages(): Array<{
+        role: string;
+        content: string;
+    }>;
+}
+type KnowledgeStoreResult = {
+    id: string;
+    sourceId: string;
+    version: number;
+    title: string;
+    isNew: boolean;
+};
+export declare function readLocalFile(filePath: string): {
+    title: string;
+    content: string;
+    originalPath: string;
+    hash: string;
+};
+export declare function copyOriginal(filePath: string, root: string): string;
+export declare function defaultDataRoot(): string;
+export declare function knowledgeBasePath(root: string, id: string): string;
+export declare function listKnowledgeBases(root: string): KnowledgeBase[];
+export declare function deleteKnowledgeBase(root: string, id: string): void;
+export declare function backupKnowledgeBase(base: KnowledgeBase, destination?: string): string;
+export declare function restoreKnowledgeBase(base: KnowledgeBase, backupPath: string): void;
+export declare function ensureKnowledgeBase(root: string, name?: string): KnowledgeBase;
+export {};

package/dist/storage.js

@@ -0,0 +1,130 @@
+import { mkdirSync, copyFileSync, existsSync, readFileSync, statSync, cpSync, rmSync, readdirSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, resolve, extname, basename } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import * as XLSX from "xlsx";
+export function tokenize(text) {
+    const segmenter = new Intl.Segmenter("zh", { granularity: "word" });
+    const words = [...segmenter.segment(text)]
+        .map(({ segment }) => segment.trim())
+        .filter((segment) => /[\p{L}\p{N}_]/u.test(segment));
+    return words.length ? words.join(" ") : text.split("").join(" ");
+}
+export class KnowledgeStore {
+    root;
+    db;
+    constructor(root) {
+        this.root = root;
+        mkdirSync(root, { recursive: true });
+        mkdirSync(join(root, "originals"), { recursive: true });
+        mkdirSync(join(root, "backups"), { recursive: true });
+        this.db = new DatabaseSync(join(root, "knowledge.db"));
+        this.db.exec("PRAGMA journal_mode = WAL;");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sources (id TEXT PRIMARY KEY, name TEXT NOT NULL, original_path TEXT NOT NULL, hash TEXT NOT NULL, created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS knowledge (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, version INTEGER NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL, tokenized_content TEXT NOT NULL, updated_at TEXT NOT NULL, current INTEGER NOT NULL DEFAULT 1, FOREIGN KEY(source_id) REFERENCES sources(id));
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_fts USING fts5(knowledge_id UNINDEXED, title, tokenized_content);
+      CREATE TABLE IF NOT EXISTS conversations (id TEXT PRIMARY KEY, role TEXT NOT NULL, content TEXT NOT NULL, created_at TEXT NOT NULL);
+    `);
+    }
+    close() { this.db.close(); }
+    addOrUpdateSource(filePath, title, content) {
+        const absolute = resolve(filePath);
+        const hash = createHash("sha256").update(content).digest("hex");
+        const now = new Date().toISOString();
+        const existing = this.db.prepare("SELECT id FROM sources WHERE original_path = ? OR hash = ? LIMIT 1").get(absolute, hash);
+        const sourceId = existing?.id ?? crypto.randomUUID();
+        if (!existing)
+            this.db.prepare("INSERT INTO sources (id,name,original_path,hash,created_at) VALUES (?,?,?,?,?)").run(sourceId, title, absolute, hash, now);
+        const latest = this.db.prepare("SELECT COALESCE(MAX(version), 0) AS version FROM knowledge WHERE source_id = ?").get(sourceId);
+        const version = Number(latest.version) + 1;
+        this.db.prepare("UPDATE knowledge SET current = 0 WHERE source_id = ?").run(sourceId);
+        const id = crypto.randomUUID();
+        this.db.prepare("INSERT INTO knowledge VALUES (?,?,?,?,?,?,?,1)").run(id, sourceId, version, title, content, tokenize(content), now);
+        this.db.prepare("INSERT INTO knowledge_fts VALUES (?,?,?)").run(id, title, tokenize(content));
+        return { id, sourceId, version, title, isNew: !existing };
+    }
+    search(query, limit = 8) {
+        const match = tokenize(query).split(/\s+/).filter(Boolean).map((part) => `"${part.replaceAll('"', '""')}"`).join(" OR ");
+        if (!match)
+            return [];
+        return this.db.prepare(`SELECT k.id, k.title, k.content, s.name AS source, k.version, k.updated_at AS updatedAt FROM knowledge_fts f JOIN knowledge k ON k.id = f.knowledge_id JOIN sources s ON s.id = k.source_id WHERE f.knowledge_fts MATCH ? AND k.current = 1 ORDER BY rank LIMIT ?`).all(match, limit);
+    }
+    read(id) {
+        return this.db.prepare("SELECT k.id,k.title,k.content,s.name AS source,k.version,k.updated_at AS updatedAt FROM knowledge k JOIN sources s ON s.id=k.source_id WHERE k.id=?").get(id);
+    }
+    sources() { return this.db.prepare("SELECT s.name,s.original_path AS path,MAX(k.updated_at) AS updatedAt,MAX(k.version) AS version FROM sources s JOIN knowledge k ON k.source_id=s.id AND k.current=1 GROUP BY s.id ORDER BY updatedAt DESC").all(); }
+    oldVersions() { return this.db.prepare("SELECT k.id,k.title,k.version,s.name AS source FROM knowledge k JOIN sources s ON s.id=k.source_id WHERE k.current=0 ORDER BY s.name,k.version").all(); }
+    removeVersions(ids) { const remove = this.db.prepare("DELETE FROM knowledge WHERE id=?"); const removeIndex = this.db.prepare("DELETE FROM knowledge_fts WHERE knowledge_id=?"); for (const id of ids) {
+        removeIndex.run(id);
+        remove.run(id);
+    } }
+    saveMessage(role, content) { this.db.prepare("INSERT INTO conversations VALUES (?,?,?,?)").run(crypto.randomUUID(), role, content, new Date().toISOString()); }
+    listMessages() { return this.db.prepare("SELECT role,content FROM conversations ORDER BY created_at").all(); }
+}
+export function readLocalFile(filePath) {
+    const originalPath = resolve(filePath);
+    const ext = extname(originalPath).toLowerCase();
+    let content;
+    if ([".md", ".txt", ".json", ".csv"].includes(ext))
+        content = readFileSync(originalPath, "utf8");
+    else if (ext === ".xlsx" || ext === ".xls") {
+        const workbook = XLSX.readFile(originalPath);
+        content = workbook.SheetNames.map((name) => `## ${name}\n${XLSX.utils.sheet_to_csv(workbook.Sheets[name])}`).join("\n\n");
+    }
+    else if (ext === ".pdf") {
+        throw new Error("PDF parsing is not available in this initial runtime; convert the PDF to Markdown or text first.");
+    }
+    else {
+        const stat = statSync(originalPath);
+        return { title: basename(originalPath), content: `[Unparseable file: ${ext || "unknown"}; ${stat.size} bytes]`, originalPath, hash: "" };
+    }
+    return { title: basename(originalPath), content, originalPath, hash: createHash("sha256").update(content).digest("hex") };
+}
+export function copyOriginal(filePath, root) {
+    const destination = join(root, "originals", `${Date.now()}-${basename(filePath)}`);
+    copyFileSync(filePath, destination);
+    return destination;
+}
+export function defaultDataRoot() {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? process.cwd();
+    return process.env.KB_DATA_DIR ?? join(home, ".kb");
+}
+export function knowledgeBasePath(root, id) { return join(root, "knowledge-bases", id); }
+export function listKnowledgeBases(root) {
+    const base = join(root, "knowledge-bases");
+    mkdirSync(base, { recursive: true });
+    return readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => ({ id: entry.name, name: entry.name, path: join(base, entry.name) }));
+}
+export function deleteKnowledgeBase(root, id) {
+    if (id === "default")
+        throw new Error("The default knowledge base cannot be deleted.");
+    rmSync(knowledgeBasePath(root, id), { recursive: true, force: true });
+}
+export function backupKnowledgeBase(base, destination) {
+    const target = destination ? resolve(destination) : join(base.path, "backups", `${base.id}-${new Date().toISOString().replaceAll(":", "-")}`);
+    mkdirSync(target, { recursive: true });
+    cpSync(join(base.path, "knowledge.db"), join(target, "knowledge.db"));
+    if (existsSync(join(base.path, "originals")))
+        cpSync(join(base.path, "originals"), join(target, "originals"), { recursive: true });
+    return target;
+}
+export function restoreKnowledgeBase(base, backupPath) {
+    const source = resolve(backupPath);
+    if (!existsSync(join(source, "knowledge.db")))
+        throw new Error("Backup does not contain knowledge.db");
+    const safety = join(base.path, "backups", `before-restore-${Date.now()}`);
+    backupKnowledgeBase(base, safety);
+    rmSync(join(base.path, "originals"), { recursive: true, force: true });
+    cpSync(join(source, "knowledge.db"), join(base.path, "knowledge.db"));
+    if (existsSync(join(source, "originals")))
+        cpSync(join(source, "originals"), join(base.path, "originals"), { recursive: true });
+}
+export function ensureKnowledgeBase(root, name = "default") {
+    const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "default";
+    const path = knowledgeBasePath(root, id);
+    mkdirSync(path, { recursive: true });
+    const store = new KnowledgeStore(path);
+    store.close();
+    return { id, name, path };
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@ganziliang/kb",
+  "version": "0.1.0",
+  "description": "Local knowledge base agent CLI",
+  "type": "module",
+  "bin": { "kb": "dist/cli.js" },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test"
+  },
+  "engines": { "node": ">=22.5.0" },
+  "dependencies": {
+    "@ganziliang/kb-model-setup": "^0.1.0",
+    "ink": "^5.1.0",
+    "react": "^18.3.1",
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@types/react": "^18.3.12",
+    "typescript": "^5.7.2"
+  }
+}