nolo-cli 0.1.19 → 0.1.21

package/client/hybridRecordStore.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createCliHybridRecordStore,
+  shouldCacheRemoteRecord,
+} from "./hybridRecordStore";
+
+function createMemoryDb(initial: Record<string, any> = {}) {
+  const store = new Map(Object.entries(initial));
+  return {
+    store,
+    db: {
+      get: async (key: string) => {
+        if (!store.has(key)) throw new Error(`not found: ${key}`);
+        return store.get(key);
+      },
+      put: async (key: string, value: any) => {
+        store.set(key, value);
+      },
+      batch: async (ops: Array<{ type: "put"; key: string; value: any }>) => {
+        for (const op of ops) {
+          if (op.type === "put") store.set(op.key, op.value);
+        }
+      },
+      iterator: ({ gte, lte }: { gte: string; lte?: string }) => (async function* () {
+        for (const entry of [...store.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+          if (entry[0] >= gte && (!lte || entry[0] <= lte)) yield entry;
+        }
+      })(),
+    },
+  };
+}
+
+describe("CLI hybrid record store", () => {
+  test("returns a local record without requiring a server", async () => {
+    const { db } = createMemoryDb({
+      "agent-user-1-a": { dbKey: "agent-user-1-a", name: "local" },
+    });
+    const store = createCliHybridRecordStore({
+      db,
+      env: {},
+      fetchImpl: async () => {
+        throw new Error("network should not be used for local hits");
+      },
+    });
+
+    await expect(store.read("agent-user-1-a")).resolves.toMatchObject({
+      name: "local",
+    });
+  });
+
+  test("reads through to the configured server on local miss and caches the record with serverOrigin", async () => {
+    const { db, store: memory } = createMemoryDb();
+    const requests: Array<{ url: string; auth: string | null }> = [];
+    const hybrid = createCliHybridRecordStore({
+      db,
+      env: {
+        NOLO_SERVER: "https://us.nolo.chat/",
+        AUTH_TOKEN: "token-1",
+      },
+      fetchImpl: async (url, init) => {
+        requests.push({
+          url: String(url),
+          auth: new Headers(init?.headers).get("Authorization"),
+        });
+        return Response.json({
+          data: {
+            dbKey: "agent-user-1-remote",
+            name: "remote",
+            updatedAt: "2026-05-13T00:00:00.000Z",
+          },
+        });
+      },
+    });
+
+    await expect(hybrid.read("agent-user-1-remote")).resolves.toMatchObject({
+      name: "remote",
+      serverOrigin: "https://us.nolo.chat",
+    });
+    expect(requests).toEqual([{
+      url: "https://us.nolo.chat/api/v1/db/read/agent-user-1-remote",
+      auth: "Bearer token-1",
+    }]);
+    expect(memory.get("agent-user-1-remote")).toMatchObject({
+      name: "remote",
+      serverOrigin: "https://us.nolo.chat",
+    });
+  });
+
+  test("keeps newer local records over stale remote records", () => {
+    expect(shouldCacheRemoteRecord(
+      { updatedAt: "2026-05-12T00:00:00.000Z" },
+      { updatedAt: "2026-05-13T00:00:00.000Z" }
+    )).toBe(false);
+    expect(shouldCacheRemoteRecord(
+      { updatedAt: "2026-05-14T00:00:00.000Z" },
+      { updatedAt: "2026-05-13T00:00:00.000Z" }
+    )).toBe(true);
+  });
+
+  test("writes and batches through the same store interface used by runtime adapters", async () => {
+    const { db, store: memory } = createMemoryDb();
+    const hybrid = createCliHybridRecordStore({ db, env: {} });
+
+    await hybrid.write("dialog-user-1-a", { id: "a" });
+    await hybrid.batch([
+      { type: "put", key: "dialog-a-msg-001", value: { role: "user" } },
+      { type: "put", key: "dialog-a-msg-002", value: { role: "assistant" } },
+    ]);
+
+    expect(memory.get("dialog-user-1-a")).toEqual({ id: "a", dbKey: "dialog-user-1-a" });
+    expect(memory.get("dialog-a-msg-001")).toEqual({ role: "user", dbKey: "dialog-a-msg-001" });
+    expect(memory.get("dialog-a-msg-002")).toEqual({ role: "assistant", dbKey: "dialog-a-msg-002" });
+  });
+});

package/client/hybridRecordStore.ts

@@ -0,0 +1,41 @@
+import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
+import {
+  createHybridRecordStore,
+  shouldCacheHybridRemoteRecord,
+  type HybridRecordKvDb,
+  type HybridRecordStore,
+} from "../agentRuntimeLocal";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type CliKvDb = HybridRecordKvDb;
+export type { HybridRecordStore };
+
+type CliHybridRecordStoreDeps = {
+  db: CliKvDb;
+  env: EnvLike;
+  fetchImpl?: typeof fetch;
+};
+
+function normalizeServer(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
+
+export function shouldCacheRemoteRecord(remoteRecord: any, localRecord: any) {
+  return shouldCacheHybridRemoteRecord(remoteRecord, localRecord);
+}
+
+export function createCliHybridRecordStore(
+  deps: CliHybridRecordStoreDeps
+): HybridRecordStore {
+  return createHybridRecordStore({
+    db: deps.db,
+    defaultServer: normalizeServer(deps.env.NOLO_SERVER || deps.env.BASE_URL || DEFAULT_NOLO_SERVER_URL),
+    authToken: resolveAuthToken(deps.env),
+    fetchImpl: deps.fetchImpl,
+  });
+}

package/client/localAgentRecords.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildLocalAgentLookupKeys,
+  shouldReadAgentKeyRemotely,
+} from "./localAgentRecords";
+
+describe("CLI local agent records", () => {
+  test("builds explicit and user-scoped agent lookup keys in order", () => {
+    expect(buildLocalAgentLookupKeys({
+      agentRef: "frontend",
+      userId: "user-1",
+    })).toEqual([
+      "frontend",
+      "agent-user-1-frontend",
+      "cybot-user-1-frontend",
+    ]);
+  });
+
+  test("only remote reads concrete agent or cybot keys", () => {
+    expect(shouldReadAgentKeyRemotely("agent-user-1-frontend")).toBe(true);
+    expect(shouldReadAgentKeyRemotely("agent-pub-01ABC")).toBe(true);
+    expect(shouldReadAgentKeyRemotely("cybot-user-1-frontend")).toBe(true);
+    expect(shouldReadAgentKeyRemotely("frontend")).toBe(false);
+    expect(shouldReadAgentKeyRemotely("dialog-user-1-frontend")).toBe(false);
+  });
+});

package/client/localAgentRecords.ts

@@ -0,0 +1,7 @@
+import {
+  buildAgentRuntimeAgentLookupKeys,
+  shouldFetchAgentRuntimeRecordRemotely,
+} from "../agentRuntimeLocal";
+
+export const buildLocalAgentLookupKeys = buildAgentRuntimeAgentLookupKeys;
+export const shouldReadAgentKeyRemotely = shouldFetchAgentRuntimeRecordRemotely;

package/client/localDialogRecords.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildLocalDialogWritePlan,
+  localDialogMessageRecordToRuntimeMessage,
+} from "./localDialogRecords";
+
+describe("CLI local dialog records", () => {
+  test("converts persisted dialog message records into runtime messages", () => {
+    expect(localDialogMessageRecordToRuntimeMessage({
+      role: "assistant",
+      content: "previous answer",
+      tool_calls: [{ id: "call-1", type: "function" }],
+    })).toEqual({
+      role: "assistant",
+      content: "previous answer",
+      tool_calls: [{ id: "call-1", type: "function" }],
+    });
+
+    expect(localDialogMessageRecordToRuntimeMessage({
+      role: "tool",
+      content: "file contents",
+      toolCallId: "call-1",
+    })).toEqual({
+      role: "tool",
+      content: "file contents",
+      tool_call_id: "call-1",
+    });
+
+    expect(localDialogMessageRecordToRuntimeMessage({ role: "system", content: "skip" })).toBeNull();
+    expect(localDialogMessageRecordToRuntimeMessage({ role: "unknown", content: "skip" })).toBeNull();
+  });
+
+  test("builds dialog meta and message write ops for a local turn", () => {
+    const plan = buildLocalDialogWritePlan({
+      input: {
+        agentKey: "agent-user-1-frontend",
+        messages: [
+          { role: "system", content: "System prompt" },
+          { role: "user", content: "make it cleaner" },
+          { role: "assistant", content: "done" },
+        ],
+        result: {
+          content: "done",
+          model: "custom-coder",
+          provider: "custom",
+          usage: { prompt_tokens: 4, completion_tokens: 3 },
+          toolCallCount: 1,
+        },
+      },
+      userId: "user-1",
+      now: 1710000000000,
+      createId: () => "01LOCAL",
+      cwd: "/repo/.worktrees/task",
+    });
+
+    expect(plan.dialogId).toBe("01LOCAL");
+    expect(plan.ops.map((op) => op.key)).toEqual([
+      "dialog-user-1-01LOCAL",
+      "dialog-01LOCAL-msg-1710000000000-001",
+      "dialog-01LOCAL-msg-1710000000000-002",
+    ]);
+    expect(plan.ops[0]?.value).toMatchObject({
+      id: "01LOCAL",
+      dbKey: "dialog-user-1-01LOCAL",
+      type: "dialog",
+      userId: "user-1",
+      cybots: ["agent-user-1-frontend"],
+      primaryAgentKey: "agent-user-1-frontend",
+      title: "make it cleaner",
+      status: "done",
+      triggerType: "cli-local",
+      executionMode: "foreground",
+      createdAt: "2024-03-09T16:00:00.000Z",
+      updatedAt: "2024-03-09T16:00:00.000Z",
+      finishedAt: 1710000000000,
+      usage: { prompt_tokens: 4, completion_tokens: 3 },
+      toolCallCount: 1,
+      localRuntime: {
+        host: "cli",
+        worktreePath: "/repo/.worktrees/task",
+      },
+    });
+    expect(plan.ops[1]?.value).toMatchObject({
+      id: "1710000000000-001",
+      dbKey: "dialog-01LOCAL-msg-1710000000000-001",
+      dialogId: "01LOCAL",
+      role: "user",
+      content: "make it cleaner",
+      userId: "user-1",
+    });
+    expect(plan.ops[2]?.value).toMatchObject({
+      role: "assistant",
+      content: "done",
+      agentKey: "agent-user-1-frontend",
+      cybotKey: "agent-user-1-frontend",
+    });
+  });
+
+  test("preserves existing dialog title and createdAt when continuing", () => {
+    const plan = buildLocalDialogWritePlan({
+      input: {
+        agentKey: "agent-user-1-frontend",
+        continueDialogId: "dialog-existing",
+        messages: [{ role: "user", content: "new task" }],
+        result: { content: "ok", model: "gpt-4.1-mini", provider: "openai" },
+      },
+      existingDialog: {
+        title: "Existing title",
+        createdAt: "2024-01-01T00:00:00.000Z",
+      },
+      userId: "user-1",
+      now: 1710000000000,
+      createId: () => "unused",
+    });
+
+    expect(plan.dialogId).toBe("dialog-existing");
+    expect(plan.ops[0]?.value).toMatchObject({
+      title: "Existing title",
+      createdAt: "2024-01-01T00:00:00.000Z",
+      updatedAt: "2024-03-09T16:00:00.000Z",
+    });
+  });
+});

package/client/localDialogRecords.ts

@@ -0,0 +1,30 @@
+import {
+  buildAgentRuntimeDialogWritePlan,
+  dialogMessageRecordToAgentRuntimeMessage,
+  type AgentRuntimeSaveTurnInput,
+} from "../agentRuntimeLocal";
+
+type LocalDialogRecord = Record<string, any>;
+
+export const localDialogMessageRecordToRuntimeMessage = dialogMessageRecordToAgentRuntimeMessage;
+
+export function buildLocalDialogWritePlan(args: {
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: number;
+  createId: () => string;
+  existingDialog?: LocalDialogRecord | null;
+  cwd?: string;
+}) {
+  return buildAgentRuntimeDialogWritePlan({
+    input: args.input,
+    userId: args.userId,
+    now: args.now,
+    createId: args.createId,
+    existingDialog: args.existingDialog,
+    runtimeHost: "cli",
+    runtimeMetadata: {
+      ...(args.cwd ? { worktreePath: args.cwd } : {}),
+    },
+  });
+}

package/client/localProviderResolver.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+
+import { resolveCliOpenAiProviderConfig } from "./localProviderResolver";
+
+describe("CLI local provider resolver", () => {
+  test("uses agent customProviderUrl as the OpenAI-compatible chat completions endpoint", () => {
+    expect(resolveCliOpenAiProviderConfig({
+      agentConfig: {
+        key: "agent-user-1-custom",
+        model: "qwen-coder",
+        provider: "custom",
+        apiSource: "custom",
+        customProviderUrl: "https://provider.example/v1/chat/completions",
+      },
+      env: {
+        OPENAI_API_KEY: "sk-env",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+    })).toEqual({
+      model: "qwen-coder",
+      endpoint: "https://provider.example/v1/chat/completions",
+      apiKey: "sk-env",
+      provider: "custom",
+      requestOptions: {},
+    });
+  });
+
+  test("appends chat completions to custom provider base urls", () => {
+    expect(resolveCliOpenAiProviderConfig({
+      agentConfig: {
+        key: "agent-user-1-custom",
+        customProviderUrl: "https://provider.example/v1/",
+      },
+      env: {},
+    }).endpoint).toBe("https://provider.example/v1/chat/completions");
+  });
+
+  test("falls back to the env OpenAI-compatible base url", () => {
+    expect(resolveCliOpenAiProviderConfig({
+      agentConfig: {
+        key: "agent-user-1-openai",
+      },
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1/",
+        NOLO_LOCAL_OPENAI_API_KEY: "sk-local",
+      },
+    })).toEqual({
+      model: "gpt-4.1-mini",
+      endpoint: "http://127.0.0.1:11434/v1/chat/completions",
+      apiKey: "sk-local",
+      provider: "openai-compatible",
+      requestOptions: {},
+    });
+  });
+
+  test("carries explicit agent inference options for request body construction", () => {
+    expect(resolveCliOpenAiProviderConfig({
+      agentConfig: {
+        key: "agent-user-1-tuned",
+        temperature: 0.2,
+        top_p: 0.9,
+        frequency_penalty: 0.1,
+        presence_penalty: 0.3,
+        max_tokens: 4096,
+        reasoning_effort: "medium",
+      },
+      env: {},
+    }).requestOptions).toEqual({
+      temperature: 0.2,
+      top_p: 0.9,
+      frequency_penalty: 0.1,
+      presence_penalty: 0.3,
+      max_tokens: 4096,
+      reasoning_effort: "medium",
+    });
+  });
+
+});

package/client/localProviderResolver.ts

@@ -0,0 +1 @@
+export { resolveOpenAiCompatibleProviderConfig as resolveCliOpenAiProviderConfig } from "../agentRuntimeLocal";