@robota-sdk/agent-cli 3.0.0-beta.53 → 3.0.0-beta.55

package/README.md

@@ -6,6 +6,8 @@ AI coding assistant CLI built on Robota SDK. Loads AGENTS.md/CLAUDE.md for proje
 
 ## Installation
 
+Requires Node.js 22+.
+
 ```bash
 # Global install
 npm install -g @robota-sdk/agent-cli
@@ -26,9 +28,9 @@ robota -p "List all files"    # Print mode (one-shot, exit after response)
 
 ### Environment Variables
 
-| Variable            | Description       | Required |
-| ------------------- | ----------------- | -------- |
-| `ANTHROPIC_API_KEY` | Anthropic API key | Yes      |
+| Variable            | Description                                    | Required       |
+| ------------------- | ---------------------------------------------- | -------------- |
+| `ANTHROPIC_API_KEY` | Anthropic API key for the `anthropic` provider | Anthropic only |
 
 Set your key before running:
 
@@ -107,12 +109,12 @@ git diff | robota -p "Summarize changes" --output-format stream-json
 
 ## First-Run Setup
 
-When no settings file exists, the CLI prompts for:
+When no usable settings file exists, the CLI prompts for:
 
 1. **Anthropic API key** (input masked with asterisks)
 2. **Response language** (ko/en/ja/zh, default: en)
 
-Creates `~/.robota/settings.json`. Use `robota --reset` to return to first-run state.
+Creates `~/.robota/settings.json`. Use `robota --reset` to return to first-run state. OpenAI-compatible local profiles, such as LM Studio, can be configured manually without using the first-run Anthropic prompt.
 
 ## Built-in Tools
 
@@ -267,22 +269,37 @@ The `/plugin` command opens an interactive TUI for managing bundle plugins:
 
 ## Configuration
 
-Settings are loaded from (highest priority first):
+Settings are merged in this order, from lowest to highest priority:
 
-1. `.robota/settings.local.json` (local, gitignored)
-2. `.robota/settings.json` (project, shared)
-3. `.claude/settings.json` (project, Claude Code compatible)
-4. `~/.robota/settings.json` (user global)
-5. `~/.claude/settings.json` (user global, Claude Code compatible)
+1. `~/.robota/settings.json` (user global)
+2. `~/.claude/settings.json` (user global, Claude Code compatible)
+3. `.robota/settings.json` (project, shared)
+4. `.robota/settings.local.json` (local, gitignored)
+5. `.claude/settings.json` (project, Claude Code compatible)
+6. `.claude/settings.local.json` (local, gitignored, Claude Code compatible)
 
 ```json
 {
   "defaultMode": "default",
   "language": "en",
-  "provider": {
-    "name": "anthropic",
-    "model": "claude-sonnet-4-6",
-    "apiKey": "$ENV:ANTHROPIC_API_KEY"
+  "currentProvider": "gemma",
+  "providers": {
+    "gemma": {
+      "type": "gemma",
+      "model": "supergemma4-26b-uncensored-v2",
+      "apiKey": "lm-studio",
+      "baseURL": "http://localhost:1234/v1"
+    },
+    "openai": {
+      "type": "openai",
+      "model": "<openai-compatible-model>",
+      "apiKey": "$ENV:OPENAI_API_KEY"
+    },
+    "anthropic": {
+      "type": "anthropic",
+      "model": "claude-sonnet-4-6",
+      "apiKey": "$ENV:ANTHROPIC_API_KEY"
+    }
   },
   "permissions": {
     "allow": ["Bash(pnpm *)"],
@@ -291,6 +308,18 @@ Settings are loaded from (highest priority first):
 }
 ```
 
+`currentProvider` selects a profile from `providers`. Gemma-family LM Studio models use `type: "gemma"` so Robota can apply Gemma-specific channel-marker projection while still talking to the OpenAI-compatible `/v1/chat/completions` API through `baseURL`. Generic OpenAI-compatible profiles use `type: "openai"` and do not apply Gemma filtering. The legacy single-provider shape remains supported:
+
+```json
+{
+  "provider": {
+    "name": "anthropic",
+    "model": "claude-sonnet-4-6",
+    "apiKey": "$ENV:ANTHROPIC_API_KEY"
+  }
+}
+```
+
 ## Context Discovery
 
 The CLI automatically discovers and loads:
@@ -309,7 +338,9 @@ All context is assembled into the system prompt.
 
 ## Session Logging
 
-Session logs are written to `.robota/logs/{sessionId}.jsonl` in JSONL format by default, capturing structured events for diagnostics and replay.
+Session logs are written to `.robota/logs/{sessionId}.jsonl` in JSONL format by default, capturing structured events for diagnostics and replay. Background task lifecycle/progress events are logged there as they happen. Child-process subagents also write append-only transcripts to `.robota/logs/{sessionId}/subagents/{agentId}.jsonl`, including streaming text deltas while the local provider request is still running.
+
+Resumable session JSON is written to `.robota/sessions/{sessionId}.json` for the current project and includes messages, UI history, the exact system prompt, registered tool schemas, and background task snapshots. High-frequency streaming chunks stay in JSONL transcript files; the session JSON stores task state and transcript paths.
 
 ## Architecture
 
@@ -345,7 +376,7 @@ bin.ts → cli.ts (arg parsing)
 | `@robota-sdk/agent-sdk`                | Session factory, query, config, context    |
 | `@robota-sdk/agent-core`               | Types (TPermissionMode, TToolArgs)         |
 | `@robota-sdk/agent-transport-headless` | Headless runner for print mode (`-p`)      |
-| `ink`, `react`                         | TUI rendering                              |
+| `ink` 7, `react` 19.2+                 | TUI rendering                              |
 | `ink-select-input`                     | Arrow-key selection (permission prompt)    |
 | `ink-spinner`                          | Loading spinner                            |
 | `chalk`                                | Terminal colors                            |

package/dist/node/bin.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import {
   startCli
-} from "./chunk-CXBD4JNS.js";
+} from "./chunk-H3NRW5FW.js";
+import "./chunk-2JAZDNYT.js";
 
 // src/bin.ts
+import { createAgentCommandModule } from "@robota-sdk/agent-command-agent";
 process.on("uncaughtException", (err) => {
   const msg = err.message ?? "";
   const isLikelyIME = msg.includes("string-width") || msg.includes("setCursorPosition") || msg.includes("getStringWidth") || msg.includes("slice") || msg.includes("charCodeAt");
@@ -14,7 +16,7 @@ process.on("uncaughtException", (err) => {
   }
   throw err;
 });
-startCli().catch((err) => {
+startCli({ commandModules: [createAgentCommandModule()] }).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
   process.stderr.write(message + "\n");
   process.exit(1);

package/dist/node/chunk-2JAZDNYT.js

@@ -0,0 +1,246 @@
+// src/utils/provider-factory.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/utils/provider-default-definitions.ts
+import { createAnthropicProviderDefinition } from "@robota-sdk/agent-provider-anthropic";
+import { createGemmaProviderDefinition } from "@robota-sdk/agent-provider-gemma";
+import { createOpenAIProviderDefinition } from "@robota-sdk/agent-provider-openai";
+var DEFAULT_PROVIDER_DEFINITIONS = [
+  createAnthropicProviderDefinition(),
+  createOpenAIProviderDefinition(),
+  createGemmaProviderDefinition()
+];
+
+// src/utils/provider-definition.ts
+import { findProviderDefinition, formatSupportedProviderTypes } from "@robota-sdk/agent-core";
+
+// src/utils/provider-factory.ts
+function readProviderSettings(cwd, options = {}) {
+  const merged = readMergedProviderSettings(cwd);
+  const providerConfig = resolveActiveProvider(
+    merged,
+    options.providerOverride,
+    getProviderDefinitions(options)
+  );
+  if (providerConfig !== void 0) {
+    return providerConfig;
+  }
+  throw new Error("No provider configuration found. Run `robota` to set up.");
+}
+function readMergedProviderSettings(cwd) {
+  const paths = [
+    join(homedir(), ".robota", "settings.json"),
+    join(homedir(), ".claude", "settings.json"),
+    join(cwd, ".robota", "settings.json"),
+    join(cwd, ".robota", "settings.local.json"),
+    join(cwd, ".claude", "settings.json"),
+    join(cwd, ".claude", "settings.local.json")
+  ];
+  return paths.reduce((settings, filePath) => {
+    const parsed = readSettingsFile(filePath);
+    if (parsed === void 0) {
+      return settings;
+    }
+    return mergeSettings(settings, parsed);
+  }, {});
+}
+function readSettingsFile(filePath) {
+  if (!existsSync(filePath)) {
+    return void 0;
+  }
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function mergeSettings(base, override) {
+  return {
+    ...base,
+    ...override,
+    provider: base.provider !== void 0 || override.provider !== void 0 ? { ...base.provider, ...override.provider } : void 0,
+    providers: base.providers !== void 0 || override.providers !== void 0 ? mergeProviders(base.providers, override.providers) : void 0
+  };
+}
+function mergeProviders(base, override) {
+  const result = { ...base ?? {} };
+  for (const [name, profile] of Object.entries(override ?? {})) {
+    result[name] = { ...result[name], ...profile };
+  }
+  return result;
+}
+function resolveActiveProvider(settings, providerOverride, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const activeProvider = providerOverride ?? settings.currentProvider;
+  if (activeProvider !== void 0) {
+    const profile = settings.providers?.[activeProvider];
+    if (profile === void 0) {
+      throw new Error(`Provider profile "${activeProvider}" was not found in providers`);
+    }
+    if (!profile.type) {
+      throw new Error(`Provider profile "${activeProvider}" is missing type`);
+    }
+    return normalizeProviderConfig(
+      {
+        name: profile.type,
+        model: profile.model,
+        apiKey: profile.apiKey,
+        baseURL: profile.baseURL,
+        timeout: profile.timeout
+      },
+      providerDefinitions
+    );
+  }
+  const provider = settings.provider;
+  if (provider?.name) {
+    return normalizeProviderConfig(
+      {
+        name: provider.name,
+        model: provider.model,
+        apiKey: provider.apiKey,
+        baseURL: provider.baseURL,
+        timeout: provider.timeout
+      },
+      providerDefinitions
+    );
+  }
+  return void 0;
+}
+function normalizeProviderConfig(settings, providerDefinitions) {
+  const defaults = findProviderDefinition(providerDefinitions, settings.name)?.defaults ?? {};
+  const model = settings.model ?? defaults.model;
+  if (!model) {
+    throw new Error(`Provider ${settings.name} requires model`);
+  }
+  return {
+    name: settings.name,
+    model,
+    apiKey: settings.apiKey !== void 0 ? resolveEnvRef(settings.apiKey) : defaults.apiKey,
+    baseURL: settings.baseURL ?? defaults.baseURL,
+    timeout: settings.timeout
+  };
+}
+function resolveEnvRef(value) {
+  const envPrefix = "$ENV:";
+  if (!value.startsWith(envPrefix)) {
+    return value;
+  }
+  const envName = value.slice(envPrefix.length);
+  return process.env[envName] ?? value;
+}
+function resolveProfileApiKey(profile) {
+  if (profile.apiKey !== void 0) {
+    return profile.apiKey;
+  }
+  if (profile.apiKeyEnv !== void 0) {
+    return process.env[profile.apiKeyEnv];
+  }
+  return void 0;
+}
+function createProviderFromConfig(settings, providerDefinitions) {
+  const definition = findProviderDefinition(providerDefinitions, settings.name);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${settings.name}. Currently supported: ${formatSupportedProviderTypes(providerDefinitions)}`
+    );
+  }
+  if (definition.requiresApiKey === true && !settings.apiKey) {
+    throw new Error(`Provider ${settings.name} requires apiKey`);
+  }
+  return definition.createProvider(settings);
+}
+function createProviderFromSettings(cwd, modelOverride, options = {}) {
+  const providerDefinitions = getProviderDefinitions(options);
+  const settings = readProviderSettings(cwd, { ...options, providerDefinitions });
+  const model = modelOverride ?? settings.model;
+  return createProviderFromConfig({ ...settings, model }, providerDefinitions);
+}
+function createProviderFromProfile(profile, modelOverride, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  return createProviderFromConfig(
+    normalizeProviderConfig(
+      {
+        name: profile.type,
+        model: modelOverride ?? profile.model,
+        apiKey: resolveProfileApiKey(profile),
+        baseURL: profile.baseURL,
+        timeout: profile.timeout
+      },
+      providerDefinitions
+    ),
+    providerDefinitions
+  );
+}
+function getProviderDefinitions(options) {
+  return options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+}
+
+// src/subagents/child-process-subagent-ipc.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasString(value, key) {
+  return typeof value[key] === "string";
+}
+function isStartPayload(value) {
+  if (!isRecord(value)) return false;
+  if (!hasString(value, "jobId")) return false;
+  if (!isRecord(value.request)) return false;
+  if (!hasString(value.request, "type")) return false;
+  if (!hasString(value.request, "prompt")) return false;
+  if (!isRecord(value.agentDefinition)) return false;
+  if (!hasString(value.agentDefinition, "name")) return false;
+  if (!hasString(value.agentDefinition, "systemPrompt")) return false;
+  if (!isRecord(value.parentConfig)) return false;
+  if (!isRecord(value.parentContext)) return false;
+  if (!isRecord(value.providerProfile)) return false;
+  if (!hasString(value.providerProfile, "type")) return false;
+  return hasString(value.providerProfile, "model");
+}
+function isSubagentWorkerParentMessage(value) {
+  if (!isRecord(value) || !hasString(value, "type")) return false;
+  switch (value.type) {
+    case "start":
+      return isStartPayload(value.payload);
+    case "send":
+      return hasString(value, "prompt");
+    case "cancel":
+      return value.reason === void 0 || typeof value.reason === "string";
+    default:
+      return false;
+  }
+}
+function isSubagentWorkerChildMessage(value) {
+  if (!isRecord(value) || !hasString(value, "type")) return false;
+  switch (value.type) {
+    case "ready":
+      return true;
+    case "text_delta":
+      return hasString(value, "delta");
+    case "tool_start":
+      return hasString(value, "toolName");
+    case "tool_end":
+      return hasString(value, "toolName") && typeof value.success === "boolean";
+    case "result":
+      return hasString(value, "output");
+    case "error":
+      return hasString(value, "message");
+    case "cancelled":
+      return value.reason === void 0 || typeof value.reason === "string";
+    default:
+      return false;
+  }
+}
+
+export {
+  DEFAULT_PROVIDER_DEFINITIONS,
+  findProviderDefinition,
+  formatSupportedProviderTypes,
+  readProviderSettings,
+  readMergedProviderSettings,
+  createProviderFromSettings,
+  createProviderFromProfile,
+  isSubagentWorkerParentMessage,
+  isSubagentWorkerChildMessage
+};