@knosi/cli 0.1.0

package/README.md

@@ -0,0 +1,32 @@
+# @knosi/cli
+
+Local Claude Code daemon for [Second Brain](https://github.com/zhousiyao03-cyber/second-brain).
+
+Runs on your machine, picks up AI tasks from the hosted Second Brain instance, executes them via your local Claude CLI, and pushes results back.
+
+## Prerequisites
+
+- [Claude CLI](https://docs.anthropic.com/en/docs/claude-code) installed and logged in (`claude --version`)
+- Node.js >= 20
+
+## Usage
+
+```bash
+npx @knosi/cli --url https://your-second-brain.vercel.app
+```
+
+The daemon will:
+1. Poll the server for queued AI tasks (chat + structured data)
+2. Execute them using your local Claude CLI
+3. Stream results back to the server
+
+Press Ctrl+C to stop.
+
+## Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--url <url>` | Second Brain server URL | `https://second-brain-self-alpha.vercel.app` |
+| `--model <model>` | Override Claude model | (from task) |
+| `--once` | Process one round then exit | `false` |
+| `--claude-bin <path>` | Path to Claude CLI binary | `claude` |

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@knosi/cli",
+  "version": "0.1.0",
+  "description": "Local Claude Code daemon for Second Brain — run AI tasks on your machine",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "bin": {
+    "knosi": "./src/index.mjs"
+  },
+  "files": [
+    "src/"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "second-brain",
+    "claude",
+    "ai",
+    "daemon"
+  ]
+}

package/src/api.mjs

@@ -0,0 +1,55 @@
+/**
+ * HTTP API client — communicates with the hosted Second Brain server.
+ */
+
+let serverUrl = "";
+
+export function configure(url) {
+  serverUrl = url.replace(/\/+$/, "");
+}
+
+export async function claimTask(taskType) {
+  const res = await fetch(`${serverUrl}/api/chat/claim`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ taskType }),
+  });
+  if (!res.ok) return null;
+  const data = await res.json();
+  return data.task ?? null;
+}
+
+export async function pushChatProgress(taskId, messages) {
+  if (messages.length === 0) return;
+  await fetch(`${serverUrl}/api/chat/progress`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ taskId, messages }),
+  });
+}
+
+export async function completeTask(taskId, { totalText, structuredResult, error } = {}) {
+  const body = { taskId };
+  if (error) {
+    body.error = error;
+  } else {
+    if (totalText != null) body.totalText = totalText;
+    if (structuredResult != null) body.structuredResult = structuredResult;
+  }
+  const res = await fetch(`${serverUrl}/api/chat/complete`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    throw new Error(`Complete API ${res.status}: ${await res.text()}`);
+  }
+}
+
+export async function sendHeartbeat(kind) {
+  await fetch(`${serverUrl}/api/daemon/ping`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ kind, version: "@knosi/cli" }),
+  }).catch(() => {});
+}

package/src/handler-chat.mjs

@@ -0,0 +1,97 @@
+import { pushChatProgress, completeTask } from "./api.mjs";
+import { spawnClaudeForChat } from "./spawn-claude.mjs";
+
+function getMessageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part && part.type === "text")
+    .map((part) => part.text ?? "")
+    .join("");
+}
+
+function flattenMessagesToPrompt(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return "";
+
+  let lastUserIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      lastUserIdx = i;
+      break;
+    }
+  }
+  if (lastUserIdx === -1) return "";
+
+  const history = messages.slice(0, lastUserIdx);
+  const lastUser = messages[lastUserIdx];
+  const currentQuestion = getMessageText(lastUser.content).trim();
+
+  if (history.length === 0) return currentQuestion;
+
+  const historyBlock = history
+    .map((m) => {
+      const role = m.role === "user" ? "用户" : "助手";
+      const text = getMessageText(m.content).trim();
+      return text ? `**${role}：** ${text}` : "";
+    })
+    .filter(Boolean)
+    .join("\n\n");
+
+  return `## 之前的对话历史\n\n${historyBlock}\n\n---\n\n## 当前问题\n\n${currentQuestion}`;
+}
+
+function ts() {
+  return new Date().toLocaleTimeString("en-GB", { hour12: false });
+}
+
+export async function handleChatTask(task) {
+  console.log(`[${ts()}] 🗨️  chat: ${task.id} (${task.model})`);
+
+  let seq = 0;
+  const pending = [];
+  let flushTimer = null;
+
+  async function flush() {
+    if (pending.length === 0) return;
+    const batch = pending.splice(0);
+    try {
+      await pushChatProgress(task.id, batch);
+    } catch {
+      // non-critical
+    }
+  }
+
+  function onText(delta) {
+    seq++;
+    pending.push({ seq, type: "text_delta", delta });
+    if (pending.length >= 8) {
+      flush();
+    } else if (!flushTimer) {
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flush();
+      }, 150);
+    }
+  }
+
+  try {
+    const prompt = flattenMessagesToPrompt(task.messages);
+    if (!prompt) throw new Error("Empty prompt from chat task messages");
+
+    const totalText = await spawnClaudeForChat({
+      prompt,
+      systemPrompt: task.systemPrompt || "",
+      model: task.model,
+      onText,
+    });
+
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    await flush();
+
+    await completeTask(task.id, { totalText });
+    console.log(`[${ts()}] ✅ chat done: ${task.id}`);
+  } catch (err) {
+    console.error(`[${ts()}] ❌ chat failed: ${task.id}`, err.message);
+    await completeTask(task.id, { error: err.message }).catch(() => {});
+  }
+}

package/src/handler-structured.mjs

@@ -0,0 +1,35 @@
+import { completeTask } from "./api.mjs";
+import { spawnClaudeForStructured } from "./spawn-claude.mjs";
+
+function ts() {
+  return new Date().toLocaleTimeString("en-GB", { hour12: false });
+}
+
+export async function handleStructuredTask(task) {
+  console.log(`[${ts()}] 📦 structured: ${task.id} (${task.model})`);
+
+  try {
+    const rawText = await spawnClaudeForStructured({
+      prompt: task.systemPrompt,
+      model: task.model,
+    });
+
+    // Extract JSON from possible markdown fences
+    const trimmed = rawText.trim();
+    const fencedMatch = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    const candidate = fencedMatch?.[1]?.trim() ?? trimmed;
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    const jsonText = (start !== -1 && end > start)
+      ? candidate.slice(start, end + 1)
+      : candidate;
+
+    JSON.parse(jsonText); // validate
+
+    await completeTask(task.id, { structuredResult: jsonText });
+    console.log(`[${ts()}] ✅ structured done: ${task.id}`);
+  } catch (err) {
+    console.error(`[${ts()}] ❌ structured failed: ${task.id}`, err.message);
+    await completeTask(task.id, { error: err.message }).catch(() => {});
+  }
+}

package/src/index.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * @knosi/cli — Local Claude Code daemon for Second Brain
+ *
+ * Usage:
+ *   npx @knosi/cli --url https://your-instance.vercel.app
+ *   npx @knosi/cli --once
+ */
+import { execSync } from "node:child_process";
+import { configure, claimTask, sendHeartbeat } from "./api.mjs";
+import { setClaudeBin } from "./spawn-claude.mjs";
+import { handleChatTask } from "./handler-chat.mjs";
+import { handleStructuredTask } from "./handler-structured.mjs";
+
+// ── Parse args ──────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+
+function getArg(flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+}
+
+const serverUrl = getArg("--url") || "https://second-brain-self-alpha.vercel.app";
+const isOnce = args.includes("--once");
+const claudeBinArg = getArg("--claude-bin") || "claude";
+
+const CHAT_POLL_MS = 2_000;
+const STRUCTURED_POLL_MS = 1_000;
+const HEARTBEAT_MS = 120_000;
+const MAX_CONCURRENT_CHAT = 3;
+const MAX_CONCURRENT_STRUCTURED = 5;
+
+// ── Preflight ───────────────────────────────────────────────────────────
+function checkClaude() {
+  try {
+    const version = execSync(`${claudeBinArg} --version`, { encoding: "utf8" }).trim();
+    console.log(`✓ Claude CLI: ${version}`);
+    return true;
+  } catch {
+    console.error(`✗ Claude CLI not found at "${claudeBinArg}"`);
+    console.error("  Install: npm install -g @anthropic-ai/claude-code");
+    console.error("  Or specify: --claude-bin /path/to/claude");
+    return false;
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────────
+configure(serverUrl);
+setClaudeBin(claudeBinArg);
+
+if (!checkClaude()) process.exit(1);
+
+function ts() {
+  return new Date().toLocaleTimeString("en-GB", { hour12: false });
+}
+
+let chatRunning = 0;
+let structuredRunning = 0;
+
+async function pollChat() {
+  if (chatRunning >= MAX_CONCURRENT_CHAT) return;
+  try {
+    const task = await claimTask("chat");
+    if (!task) return;
+    chatRunning++;
+    handleChatTask(task)
+      .catch(() => {})
+      .finally(() => { chatRunning--; });
+  } catch {
+    // server unreachable
+  }
+}
+
+async function pollStructured() {
+  if (structuredRunning >= MAX_CONCURRENT_STRUCTURED) return;
+  try {
+    const task = await claimTask("structured");
+    if (!task) return;
+    structuredRunning++;
+    handleStructuredTask(task)
+      .catch(() => {})
+      .finally(() => { structuredRunning--; });
+  } catch {
+    // server unreachable
+  }
+}
+
+if (isOnce) {
+  console.log("🔍 Single-run mode...");
+  await pollChat();
+  await pollStructured();
+  console.log("Done.");
+} else {
+  console.log("");
+  console.log("🚀 Knosi AI Daemon");
+  console.log(`   Server: ${serverUrl}`);
+  console.log(`   Chat poll: ${CHAT_POLL_MS / 1000}s | Structured poll: ${STRUCTURED_POLL_MS / 1000}s`);
+  console.log(`   Max concurrent: chat=${MAX_CONCURRENT_CHAT} structured=${MAX_CONCURRENT_STRUCTURED}`);
+  console.log("");
+  console.log("   Waiting for tasks... (Ctrl+C to stop)");
+  console.log("");
+
+  // Heartbeat
+  await sendHeartbeat("daemon");
+  setInterval(() => sendHeartbeat("daemon"), HEARTBEAT_MS);
+
+  // Poll loops
+  setInterval(pollChat, CHAT_POLL_MS);
+  setInterval(pollStructured, STRUCTURED_POLL_MS);
+
+  // Graceful shutdown
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.on(sig, () => {
+      console.log(`\n[${ts()}] daemon stopped`);
+      process.exit(0);
+    });
+  }
+}

package/src/spawn-claude.mjs

@@ -0,0 +1,119 @@
+import { spawn as cpSpawn } from "node:child_process";
+
+let claudeBin = "claude";
+
+export function setClaudeBin(bin) {
+  claudeBin = bin;
+}
+
+/**
+ * Chat mode: streams text deltas via onText callback, returns final text.
+ */
+export function spawnClaudeForChat({ prompt, systemPrompt, model, onText }) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-p", prompt,
+      "--system-prompt", systemPrompt,
+      "--tools", "",
+      "--output-format", "stream-json",
+      "--include-partial-messages",
+      "--verbose",
+    ];
+    if (model) args.push("--model", model);
+
+    const child = cpSpawn(claudeBin, args, {
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    const stderrChunks = [];
+    let finalResult = "";
+    let lineBuf = "";
+
+    child.stdout.on("data", (chunk) => {
+      lineBuf += chunk.toString("utf8");
+      const lines = lineBuf.split("\n");
+      lineBuf = lines.pop();
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "stream_event" && event.event) {
+            const se = event.event;
+            if (
+              se.type === "content_block_delta" &&
+              se.delta?.type === "text_delta" &&
+              typeof se.delta.text === "string"
+            ) {
+              onText(se.delta.text);
+            }
+            continue;
+          }
+          if (event.type === "result" && typeof event.result === "string") {
+            finalResult = event.result;
+          }
+        } catch {
+          // skip
+        }
+      }
+    });
+
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        reject(new Error(`claude exited with code ${code}${stderr ? `: ${stderr}` : ""}`));
+        return;
+      }
+      resolve(finalResult);
+    });
+  });
+}
+
+/**
+ * Structured mode: non-streaming, returns full text result.
+ */
+export function spawnClaudeForStructured({ prompt, model }) {
+  return new Promise((resolve, reject) => {
+    const systemPrompt =
+      "You are a structured data generator. Always return exactly one JSON object with no markdown fences or extra prose.";
+
+    const args = [
+      "-p", prompt,
+      "--system-prompt", systemPrompt,
+      "--tools", "",
+      "--output-format", "json",
+      "--verbose",
+    ];
+    if (model) args.push("--model", model);
+
+    const child = cpSpawn(claudeBin, args, {
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    const stderrChunks = [];
+    let stdout = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        reject(new Error(`claude exited with code ${code}${stderr ? `: ${stderr}` : ""}`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        resolve(typeof parsed.result === "string" ? parsed.result : stdout);
+      } catch {
+        resolve(stdout);
+      }
+    });
+  });
+}