@kody-ade/kody-engine 0.4.286 → 0.4.288

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.286",
+      version: "0.4.288",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -443,7 +443,7 @@ var STATE_BRANCH;
 var init_stateBranch = __esm({
   "src/stateBranch.ts"() {
     "use strict";
-    STATE_BRANCH = "kody-state";
+    STATE_BRANCH = "main";
   }
 });
 
@@ -497,18 +497,33 @@ function normalizeStatePath(raw, field = "statePath") {
   }
   return parts.join("/");
 }
+function normalizeStateBranch(raw, field = "state.branch") {
+  const value = raw?.trim() || STATE_BRANCH;
+  if (!value) throw new Error(`kody.config.json: ${field} must not be empty`);
+  if (value.startsWith("/") || value.endsWith("/") || value.includes("\\") || value.includes("..") || value.includes("@{") || /[\x00-\x20\x7f~^:?*\[]/.test(value)) {
+    throw new Error(`kody.config.json: ${field} contains an invalid branch`);
+  }
+  for (const part of value.split("/")) {
+    if (!part || part === "." || part === ".." || part.startsWith(".") || part.endsWith(".lock")) {
+      throw new Error(`kody.config.json: ${field} contains an invalid branch`);
+    }
+  }
+  return value;
+}
 function resolveStateRepoConfig(config) {
   if (config.state?.repo && config.state?.path) {
     parseStateRepoSlug(config.state.repo);
     return {
       repo: config.state.repo,
-      path: normalizeStatePath(config.state.path)
+      path: normalizeStatePath(config.state.path),
+      branch: normalizeStateBranch(config.state.branch)
     };
   }
   if (config.github?.owner && config.github?.repo) {
     return {
       repo: `${config.github.owner}/kody-state`,
-      path: normalizeStatePath(config.github.repo)
+      path: normalizeStatePath(config.github.repo),
+      branch: normalizeStateBranch(void 0)
     };
   }
   throw new Error("stateRepo: config.state or config.github owner/repo is required");
@@ -516,7 +531,7 @@ function resolveStateRepoConfig(config) {
 function parseStateRepo(config) {
   const state = resolveStateRepoConfig(config);
   const parsed = parseStateRepoSlug(state.repo);
-  return { ...parsed, basePath: state.path };
+  return { ...parsed, basePath: state.path, branch: state.branch };
 }
 function stateRepoPath(config, filePath) {
   const state = resolveStateRepoConfig(config);
@@ -528,14 +543,15 @@ function apiPath(config, targetPath) {
   return `/repos/${parsed.owner}/${parsed.repo}/contents/${targetPath}`;
 }
 function branchApiPath(config, targetPath) {
-  return `${apiPath(config, targetPath)}?ref=${encodeURIComponent(STATE_BRANCH)}`;
+  const state = resolveStateRepoConfig(config);
+  return `${apiPath(config, targetPath)}?ref=${encodeURIComponent(state.branch)}`;
 }
 function ensureStateBranch(config, cwd) {
   const parsed = parseStateRepo(config);
-  const cacheKey3 = `${parsed.owner}/${parsed.repo}:${STATE_BRANCH}`;
+  const cacheKey3 = `${parsed.owner}/${parsed.repo}:${parsed.branch}`;
   if (ensuredStateBranches.has(cacheKey3)) return;
   try {
-    gh(["api", `/repos/${parsed.owner}/${parsed.repo}/git/ref/heads/${STATE_BRANCH}`], { cwd });
+    gh(["api", `/repos/${parsed.owner}/${parsed.repo}/git/ref/heads/${parsed.branch}`], { cwd });
     ensuredStateBranches.add(cacheKey3);
     return;
   } catch (err) {
@@ -550,7 +566,7 @@ function ensureStateBranch(config, cwd) {
   try {
     gh(["api", "--method", "POST", `/repos/${parsed.owner}/${parsed.repo}/git/refs`, "--input", "-"], {
       cwd,
-      input: JSON.stringify({ ref: `refs/heads/${STATE_BRANCH}`, sha })
+      input: JSON.stringify({ ref: `refs/heads/${parsed.branch}`, sha })
     });
   } catch (err) {
     if (!isAlreadyExists(err)) throw err;
@@ -590,7 +606,7 @@ function writeStateText(config, cwd, filePath, content, message, sha) {
   const payload = {
     message,
     content: Buffer.from(content, "utf-8").toString("base64"),
-    branch: STATE_BRANCH
+    branch: resolveStateRepoConfig(config).branch
   };
   if (sha) payload.sha = sha;
   gh(["api", "--method", "PUT", apiPath(config, targetPath), "--input", "-"], {
@@ -655,11 +671,51 @@ function parseProviderModel(s) {
   }
   return { provider: s.slice(0, slash), model: s.slice(slash + 1) };
 }
+function optionalRuntimeString(raw, key) {
+  const value = raw[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function parseModelRuntimeConfig(modelSpec, rawConfig) {
+  const fallback = parseProviderModel(modelSpec);
+  const raw = rawConfig?.trim();
+  if (!raw) return fallback;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`KODY_MODEL_CONFIG is invalid JSON: ${msg}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("KODY_MODEL_CONFIG must be a JSON object");
+  }
+  const record2 = parsed;
+  const modelName = optionalRuntimeString(record2, "modelName");
+  if (!modelName) {
+    throw new Error("KODY_MODEL_CONFIG.modelName is required");
+  }
+  const protocol = optionalRuntimeString(record2, "protocol");
+  const baseURL = optionalRuntimeString(record2, "baseURL");
+  const apiKeyEnvVar = optionalRuntimeString(record2, "apiKeyEnvVar");
+  const spec = optionalRuntimeString(record2, "spec");
+  const provider = optionalRuntimeString(record2, "provider") ?? fallback.provider;
+  const out = {
+    provider,
+    model: modelName
+  };
+  if (protocol) out.protocol = protocol;
+  if (baseURL) out.baseURL = baseURL;
+  if (apiKeyEnvVar) out.apiKeyEnvVar = apiKeyEnvVar;
+  if (spec) out.spec = spec;
+  if (protocol === "openai") out.litellmProvider = "openai";
+  return out;
+}
 function providerApiKeyEnvVar(provider) {
   if (provider === "anthropic" || provider === "claude") return "ANTHROPIC_API_KEY";
   return `${provider.toUpperCase()}_API_KEY`;
 }
 function needsLitellmProxy(model) {
+  if (model.protocol === "anthropic") return false;
   return model.provider !== "claude" && model.provider !== "anthropic";
 }
 function loadConfig(projectDir = process.cwd()) {
@@ -722,12 +778,14 @@ function parseStateConfig(raw, github) {
   const nested = recordValue(raw.state) ?? {};
   const repoRaw = typeof raw.stateRepo === "string" ? raw.stateRepo : nested.repo;
   const pathRaw = typeof raw.statePath === "string" ? raw.statePath : nested.path;
+  const branchRaw = typeof raw.stateBranch === "string" ? raw.stateBranch : nested.branch;
   const stateRepo = typeof repoRaw === "string" && repoRaw.trim().length > 0 ? repoRaw.trim() : `https://github.com/${String(github.owner)}/kody-state`;
   parseStateRepoSlug(stateRepo);
   const statePath = typeof pathRaw === "string" && pathRaw.trim().length > 0 ? pathRaw.trim() : String(github.repo);
   return {
     repo: stateRepo,
-    path: normalizeStatePath(statePath)
+    path: normalizeStatePath(statePath),
+    branch: typeof branchRaw === "string" && branchRaw.trim().length > 0 ? normalizeStateBranch(branchRaw) : normalizeStateBranch(void 0)
   };
 }
 function parseAccessConfig(raw) {
@@ -2423,14 +2481,50 @@ function listRepairCandidates(repoSlug) {
 function dispatchVerb(workflowFile, repoSlug, capability, prNumber) {
   return dispatchWorkflow(workflowFile, capability, prNumber, repoSlug);
 }
-function postRecommendation(prNumber, mention, message, capabilitySlug) {
+function capabilityMarker(slug2) {
+  return `<!-- kody-capability: ${slug2} -->`;
+}
+function normalizeRecommendationIntent(body) {
+  const marker = body.match(/<!--\s*kody-intent:\s*([\s\S]*?)-->/i);
+  if (marker?.[1]) return marker[1].trim().replace(/\s+/g, " ").toLowerCase();
+  const legacy = body.match(/(?:^|\n)\s*(?:kody-cmd:\s*|@kody\s+)([a-z][\w-]*(?:\s+--pr\s+\d+)?)/i);
+  if (legacy?.[1]) return legacy[1].trim().replace(/\s+/g, " ").toLowerCase();
+  return null;
+}
+function containsExecutableKodyCommand(body) {
+  return /@kody\b/i.test(body) || /\bkody-cmd\s*:/i.test(body);
+}
+function recommendationAlreadyExists(repoSlug, prNumber, body, capabilitySlug) {
+  const requestedIntent = normalizeRecommendationIntent(body);
+  const requestedText = body.trim().replace(/\s+/g, " ");
+  const raw = gh(["issue", "view", String(prNumber), "-R", repoSlug, "--json", "comments"]);
+  const parsed = JSON.parse(raw);
+  return (parsed.comments ?? []).some((comment) => {
+    const existing = comment.body ?? "";
+    if (capabilitySlug && !existing.includes(capabilityMarker(capabilitySlug))) return false;
+    const existingIntent = normalizeRecommendationIntent(existing);
+    if (requestedIntent && existingIntent) return requestedIntent === existingIntent;
+    if (capabilitySlug && requestedIntent) return true;
+    return existing.trim().replace(/\s+/g, " ").includes(requestedText);
+  });
+}
+function postRecommendation(repoSlug, prNumber, mention, message, capabilitySlug) {
+  if (containsExecutableKodyCommand(message)) {
+    return {
+      ok: false,
+      error: "recommendation body contains executable Kody command text; use inert kody-intent metadata"
+    };
+  }
   const mentioned = mention ? `${mention} ${message}` : message;
   const body = capabilitySlug ? `${mentioned}
 
-<!-- kody-capability: ${capabilitySlug} -->` : mentioned;
+${capabilityMarker(capabilitySlug)}` : mentioned;
   try {
-    gh(["pr", "comment", String(prNumber), "--body", body]);
-    return { ok: true };
+    if (recommendationAlreadyExists(repoSlug, prNumber, body, capabilitySlug)) {
+      return { ok: true, posted: false };
+    }
+    gh(["issue", "comment", String(prNumber), "-R", repoSlug, "--body-file", "-"], { input: body });
+    return { ok: true, posted: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
@@ -2671,8 +2765,8 @@ function capabilityToolDefinitions(opts) {
     handler: async (args) => {
       const pr = Number(args.pr);
       const body = String(args.body ?? "");
-      const result = postRecommendation(pr, opts.operatorMention, body, opts.capabilitySlug);
-      const text = result.ok ? `Recommendation posted on PR #${pr}.` : `Recommendation failed on PR #${pr}: ${result.error}`;
+      const result = postRecommendation(opts.repoSlug, pr, opts.operatorMention, body, opts.capabilitySlug);
+      const text = result.ok ? result.posted ? `Recommendation posted on PR #${pr}.` : `Recommendation already exists on PR #${pr}; skipped.` : `Recommendation failed on PR #${pr}: ${result.error}`;
       return { content: [{ type: "text", text }] };
     }
   };
@@ -5836,13 +5930,16 @@ function resolveLitellmTimeoutMs() {
   return DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC * 1e3;
 }
 function generateLitellmConfigYaml(model) {
-  const apiKeyVar = providerApiKeyEnvVar(model.provider);
+  const apiKeyVar = model.apiKeyEnvVar ?? providerApiKeyEnvVar(model.provider);
+  const litellmProvider = model.litellmProvider ?? model.provider;
+  const providerParams = model.baseURL ? [["api_base", model.baseURL]] : [];
   return [
     "model_list:",
     `  - model_name: ${model.model}`,
     `    litellm_params:`,
-    `      model: ${model.provider}/${model.model}`,
+    `      model: ${litellmProvider}/${model.model}`,
     `      api_key: os.environ/${apiKeyVar}`,
+    ...providerParams.map(([key, value]) => `      ${key}: ${value}`),
     "",
     "litellm_settings:",
     "  drop_params: true",
@@ -6878,6 +6975,7 @@ function stateRepoContext(config, goalId, logPath) {
     return {
       repo: state.repo,
       path: state.path,
+      branch: state.branch,
       goalStatePath: `${state.path}/${goalStateLogPath(goalId)}`,
       logPath: `${state.path}/${logPath}`
     };
@@ -6976,16 +7074,17 @@ function linkContext(stateRepo) {
   const server = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
   if (runId && repository) links.workflowRun = `${server}/${repository}/actions/runs/${runId}`;
   const repo = stringValue(stateRepo?.repo);
+  const branch = stringValue(stateRepo?.branch);
   const goalStatePath2 = stringValue(stateRepo?.goalStatePath);
   const logPath = stringValue(stateRepo?.logPath);
-  if (repo && goalStatePath2) links.goalState = githubBlobUrl(repo, goalStatePath2);
-  if (repo && logPath) links.log = githubBlobUrl(repo, logPath);
+  if (repo && branch && goalStatePath2) links.goalState = githubBlobUrl(repo, branch, goalStatePath2);
+  if (repo && branch && logPath) links.log = githubBlobUrl(repo, branch, logPath);
   return Object.keys(links).length > 0 ? links : void 0;
 }
-function githubBlobUrl(repo, filePath) {
+function githubBlobUrl(repo, branch, filePath) {
   try {
     const parsed = parseStateRepoSlug(repo);
-    return `https://github.com/${parsed.owner}/${parsed.repo}/blob/${STATE_BRANCH}/${filePath}`;
+    return `https://github.com/${parsed.owner}/${parsed.repo}/blob/${encodeURIComponent(branch)}/${filePath}`;
   } catch {
     return void 0;
   }
@@ -7068,7 +7167,6 @@ var LOGS_KEY, LOG_RUN_KEY, LOG_STARTED_KEY;
 var init_runLog = __esm({
   "src/goal/runLog.ts"() {
     "use strict";
-    init_stateBranch();
     init_stateRepo();
     init_state2();
     LOGS_KEY = "__goalRunLogs";
@@ -17536,7 +17634,7 @@ function overlayDirectoryChildren(cwd, sourceDir, localDir) {
 function hydrateStateWorkspace(config, cwd) {
   if (process.env.VITEST && process.env[TEST_FETCH_ENV] !== "1") return;
   const parsed = parseStateRepo(config);
-  const hydrateKey = `${path41.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${STATE_BRANCH}`;
+  const hydrateKey = `${path41.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${parsed.branch}`;
   if (hydratedWorkspaces.has(hydrateKey)) return;
   const snapshotRoot = fetchStateSnapshot(parsed);
   for (const mapping of DIR_MAPPINGS) {
@@ -17560,7 +17658,7 @@ function fetchStateSnapshot(parsed) {
       runGit3(["clone", "--no-checkout", "--filter=blob:none", url, cacheDir]);
     }
     runGit3(["-C", cacheDir, "remote", "set-url", "origin", url]);
-    runGit3(["-C", cacheDir, "fetch", "--depth=1", "origin", STATE_BRANCH]);
+    runGit3(["-C", cacheDir, "fetch", "--depth=1", "origin", parsed.branch]);
     runGit3(["-C", cacheDir, "sparse-checkout", "init", "--cone"]);
     runGit3(["-C", cacheDir, "sparse-checkout", "set", parsed.basePath]);
     runGit3(["-C", cacheDir, "checkout", "--force", "--detach", "FETCH_HEAD"]);
@@ -17568,7 +17666,7 @@ function fetchStateSnapshot(parsed) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(
-      `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${STATE_BRANCH}: ${msg}`
+      `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${parsed.branch}: ${msg}`
     );
   }
   return path41.join(cacheDir, parsed.basePath);
@@ -17577,7 +17675,7 @@ function cacheRoot2() {
   return process.env[CACHE_ENV2]?.trim() || path41.join(os7.homedir(), ".cache", "kody", "state-repo");
 }
 function cacheKey2(parsed) {
-  return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${STATE_BRANCH}#${parsed.basePath}`).digest("hex").slice(0, 24);
+  return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${parsed.branch}#${parsed.basePath}`).digest("hex").slice(0, 24);
 }
 function runGit3(args) {
   try {
@@ -17612,7 +17710,6 @@ var DIR_MAPPINGS, FILE_MAPPINGS, CACHE_ENV2, TEST_FETCH_ENV, hydratedWorkspaces;
 var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
-    init_stateBranch();
     init_stateRepo();
     DIR_MAPPINGS = [
       { stateDir: "executables", localDir: path41.join(".kody", "executables") },
@@ -19367,6 +19464,16 @@ var CHAT_SYSTEM_PROMPT = [
   "Do not invent file paths, commit SHAs, line numbers, or command output. If you",
   "cite something concrete, you must have just read or run it in this session."
 ].join("\n");
+var OPENAI_CHAT_SYSTEM_PROMPT = [
+  "You are Kody, an AI assistant for the Kody Operations Dashboard. Reply to the",
+  "user's latest message using the full conversation below as context. Keep replies",
+  "short and simple. Use plain terms, not jargon.",
+  "",
+  "This chat is running through an OpenAI-compatible model endpoint. Answer directly",
+  "from the conversation and provided context. Do not claim to run shell commands,",
+  "edit files, inspect the repository, or use tools unless the user has supplied",
+  "the relevant content in the chat."
+].join("\n");
 var CROSS_REPO_PROMPT = [
   "# Working across repositories",
   "You are NOT limited to the repository at your current working directory. You",
@@ -19428,7 +19535,7 @@ async function runChatTurn(opts) {
     return { exitCode: 64, error };
   }
   const { turns: promptTurns, imagePaths } = prepareAttachments(turns, opts.cwd, opts.sessionId);
-  const basePrompt = opts.systemPrompt ?? CHAT_SYSTEM_PROMPT;
+  const basePrompt = opts.systemPrompt ?? (opts.model.protocol === "openai" ? OPENAI_CHAT_SYSTEM_PROMPT : CHAT_SYSTEM_PROMPT);
   const catalog = buildExecutableCatalog();
   const taskArtifactsPaths = prepareTaskArtifactsDir(opts.cwd, opts.sessionId);
   const artifactAddendum = taskArtifactsPromptAddendum({
@@ -19462,6 +19569,14 @@ async function runChatTurn(opts) {
     artifactAddendum
   ].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
   const prompt = buildPrompt(promptTurns);
+  if (opts.model.protocol === "openai" && opts.litellmUrl) {
+    return runOpenAIChatTurn({
+      opts,
+      turns: promptTurns,
+      systemPrompt,
+      sessionFile: opts.sessionFile
+    });
+  }
   let progressSeq = 0;
   const invoke = opts.invokeAgent ?? ((p) => runAgent({
     prompt: p,
@@ -19564,6 +19679,74 @@ async function runChatTurn(opts) {
   }
   return { exitCode: 0, reply };
 }
+async function runOpenAIChatTurn(args) {
+  const { opts, turns, systemPrompt, sessionFile } = args;
+  const doFetch = opts.fetchImpl ?? fetch;
+  const url = `${opts.litellmUrl.replace(/\/+$/, "")}/v1/chat/completions`;
+  try {
+    const response = await doFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts.model.model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          ...turns.map((turn) => ({
+            role: turn.role,
+            content: turn.content
+          }))
+        ],
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      const error = `OpenAI-compatible model request failed ${response.status}${text ? `: ${text.slice(0, 500)}` : ""}`;
+      await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+      return { exitCode: 99, error };
+    }
+    const payload = await response.json();
+    const reply = extractOpenAIReply(payload).trim();
+    if (!reply) {
+      const error = typeof payload.error?.message === "string" ? payload.error.message : "OpenAI-compatible model completed without producing a reply";
+      await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+      return { exitCode: 99, error };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    appendTurn(sessionFile, {
+      role: "assistant",
+      content: reply,
+      timestamp: now
+    });
+    await emit(opts.sink, "chat.message", opts.sessionId, "message", {
+      sessionId: opts.sessionId,
+      role: "assistant",
+      content: reply,
+      timestamp: now
+    });
+    await emit(opts.sink, "chat.done", opts.sessionId, "done", { sessionId: opts.sessionId });
+    return { exitCode: 0, reply };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 99, error };
+  }
+}
+function extractOpenAIReply(payload) {
+  const content = payload.choices?.[0]?.message?.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (part && typeof part === "object" && "text" in part) {
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+}
 function buildPrompt(turns) {
   const body = turns.map((t) => `${t.role === "user" ? "User" : "Assistant"}: ${t.content}`).join("\n\n");
   return `${body}
@@ -21406,7 +21589,10 @@ async function brainServe(opts) {
   }
   const apiKey = getApiKey();
   const port = Number(process.env.PORT ?? DEFAULT_PORT);
-  const model = parseProviderModel(process.env.MODEL?.trim() || "claude/claude-haiku-4-5-20251001");
+  const model = parseModelRuntimeConfig(
+    process.env.MODEL?.trim() || "claude/claude-haiku-4-5-20251001",
+    process.env.KODY_MODEL_CONFIG
+  );
   const usesProxy = needsLitellmProxy(model);
   let handle = null;
   if (usesProxy) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.286",
+  "version": "0.4.288",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",