thoth-agents 0.1.19 → 0.2.1

package/dist/chunk-4WYCZ5Z7.js

@@ -0,0 +1,698 @@
+import {
+  DEFAULT_MODELS,
+  OPENCODE_PROMPT_DIALECT,
+  SUBAGENT_NAMES,
+  appendPromptSections,
+  composeAgentPrompt,
+  createOrchestratorPromptSections,
+  createReadOnlySpecialistPromptSections,
+  createWriteCapableSpecialistPromptSections,
+  detectModelFamily,
+  getAgentOverride,
+  getModelFamilyPromptSection,
+  getStepBudgetPromptSection,
+  loadAgentPrompt,
+  renderRolePrompt
+} from "./chunk-3NOVCFN7.js";
+
+// src/agents/deep.ts
+var DEEP_PROMPT = renderRolePrompt(
+  createWriteCapableSpecialistPromptSections("deep"),
+  OPENCODE_PROMPT_DIALECT
+);
+function createDeepAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: DEEP_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("deep", model),
+      customAppendPrompt
+    )
+  });
+  return {
+    name: "deep",
+    description: "Synchronous write-capable implementation agent optimized for thorough context analysis, edge cases, and correctness \u2014 not for bulk mechanical changes.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      color: "secondary"
+      // steps: 80,
+    }
+  };
+}
+
+// src/agents/designer.ts
+var DESIGNER_PROMPT = renderRolePrompt(
+  createWriteCapableSpecialistPromptSections("designer"),
+  OPENCODE_PROMPT_DIALECT
+);
+function createDesignerAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: DESIGNER_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("designer", model),
+      customAppendPrompt
+    )
+  });
+  return {
+    name: "designer",
+    description: "Synchronous write-capable UI/UX implementation agent with ownership of approach, execution, and visual verification.",
+    config: {
+      model,
+      temperature: 0.4,
+      prompt,
+      color: "accent"
+      // steps: 50,
+    }
+  };
+}
+
+// src/agents/explorer.ts
+var EXPLORER_PROMPT = renderRolePrompt(
+  createReadOnlySpecialistPromptSections("explorer"),
+  OPENCODE_PROMPT_DIALECT
+);
+function createExplorerAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: EXPLORER_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("explorer", model),
+      customAppendPrompt
+    )
+  });
+  return {
+    name: "explorer",
+    description: "Read-only local discovery agent for fast codebase search, references, and repository mapping.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      color: "info"
+    }
+  };
+}
+
+// src/agents/librarian.ts
+var LIBRARIAN_PROMPT = renderRolePrompt(
+  createReadOnlySpecialistPromptSections("librarian"),
+  OPENCODE_PROMPT_DIALECT
+);
+function createLibrarianAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: LIBRARIAN_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("librarian", model),
+      customAppendPrompt
+    )
+  });
+  return {
+    name: "librarian",
+    description: "Read-only research agent for official docs, public examples, and externally sourced implementation guidance.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      color: "info"
+    }
+  };
+}
+
+// src/agents/oracle.ts
+var ORACLE_PROMPT = renderRolePrompt(
+  createReadOnlySpecialistPromptSections("oracle"),
+  OPENCODE_PROMPT_DIALECT
+);
+function createOracleAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: ORACLE_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("oracle", model),
+      customAppendPrompt
+    )
+  });
+  return {
+    name: "oracle",
+    description: "Synchronous read-only strategic advisor for debugging, architecture, code review, and SDD plan review.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      color: "warning"
+    }
+  };
+}
+
+// src/agents/orchestrator.ts
+var OPENCODE_RUNTIME_SECTION = `<opencode-runtime>
+In the OpenCode harness, an automatic \`<reminder>...</reminder>\` workflow block followed by a \`\\n\\n---\\n\\n\` separator is prepended to your user messages as harness scaffolding, not user input.
+When saving the user prompt via mem_save(kind="prompt"), you MUST exclude that injected \`<reminder>\` block and the \`---\` separator, and persist only the real user request text that follows.
+</opencode-runtime>`;
+var ORCHESTRATOR_PROMPT = appendPromptSections(
+  renderRolePrompt(createOrchestratorPromptSections(), OPENCODE_PROMPT_DIALECT),
+  OPENCODE_RUNTIME_SECTION
+);
+function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: ORCHESTRATOR_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("orchestrator", model),
+      customAppendPrompt
+    )
+  });
+  const definition = {
+    name: "orchestrator",
+    description: "Delegate-first coordinator for SDD workflow, specialist dispatch, and root-session memory ownership.",
+    config: {
+      temperature: 0.1,
+      prompt,
+      color: "primary"
+      // steps: 100,
+    }
+  };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map(
+      (entry) => typeof entry === "string" ? { id: entry } : entry
+    );
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+
+// src/agents/quick.ts
+var QUICK_PROMPT = renderRolePrompt(
+  createWriteCapableSpecialistPromptSections("quick"),
+  OPENCODE_PROMPT_DIALECT
+);
+function createQuickAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = composeAgentPrompt({
+    basePrompt: QUICK_PROMPT,
+    customPrompt,
+    customAppendPrompt: appendPromptSections(
+      getModelFamilyPromptSection("quick", model),
+      customAppendPrompt
+    )
+  });
+  return {
+    name: "quick",
+    description: "Synchronous write-capable implementation agent optimized for fast, mechanical, well-bounded changes \u2014 including uniform patterns across multiple files.",
+    config: {
+      model,
+      temperature: 0.2,
+      prompt,
+      color: "success"
+      // steps: 30,
+    }
+  };
+}
+
+// src/agents/index.ts
+var GEMINI_DEFAULT_STEPS = {
+  explorer: 120,
+  librarian: 80,
+  oracle: 80,
+  designer: 80,
+  quick: 40,
+  deep: 120
+};
+var BUILTIN_PERMISSION_PRESETS = {
+  orchestrator: {
+    read: "allow",
+    edit: "allow",
+    write: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    bash: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    skill: "allow",
+    question: "allow",
+    webfetch: "allow",
+    exa: "allow",
+    todowrite: "allow",
+    task: "allow",
+    external_directory: "allow"
+  },
+  explorer: {
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    external_directory: "allow",
+    bash: "allow",
+    question: "allow",
+    skill: "allow",
+    edit: "deny",
+    todowrite: "deny",
+    task: "deny"
+  },
+  librarian: {
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    external_directory: "allow",
+    bash: "allow",
+    webfetch: "allow",
+    exa: "allow",
+    codesearch: "allow",
+    question: "allow",
+    skill: "allow",
+    edit: "deny",
+    todowrite: "deny",
+    task: "deny"
+  },
+  oracle: {
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    lsp: "allow",
+    codesearch: "allow",
+    webfetch: "allow",
+    exa: "allow",
+    external_directory: "allow",
+    bash: "allow",
+    question: "allow",
+    skill: "allow",
+    edit: "deny",
+    todowrite: "deny",
+    task: "deny"
+  },
+  designer: {
+    read: "allow",
+    edit: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    bash: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    skill: "allow",
+    question: "allow",
+    todowrite: "deny",
+    task: "deny",
+    external_directory: {
+      "~/.config/opencode/skills/**": "allow"
+    }
+  },
+  quick: {
+    read: "allow",
+    edit: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    bash: "allow",
+    question: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    skill: "allow",
+    todowrite: "deny",
+    task: "deny",
+    external_directory: {
+      "~/.config/opencode/skills/**": "allow"
+    }
+  },
+  deep: {
+    read: "allow",
+    edit: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    bash: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    skill: "allow",
+    question: "allow",
+    webfetch: "allow",
+    exa: "allow",
+    todowrite: "deny",
+    task: "deny",
+    external_directory: {
+      "~/.config/opencode/skills/**": "allow"
+    }
+  }
+};
+function normalizeModelArray(model) {
+  return model.map(
+    (entry) => typeof entry === "string" ? { id: entry } : entry
+  );
+}
+function applyOverrides(agent, override) {
+  if (override.model) {
+    if (Array.isArray(override.model)) {
+      agent._modelArray = normalizeModelArray(override.model);
+      agent.config.model = void 0;
+    } else {
+      agent.config.model = override.model;
+    }
+  }
+  if (override.variant) {
+    agent.config.variant = override.variant;
+  }
+  if (override.temperature !== void 0) {
+    agent.config.temperature = override.temperature;
+  }
+  if (override.steps !== void 0) {
+    agent.config.steps = override.steps;
+  }
+}
+function applyStepBudgetPrompt(agent) {
+  const stepBudgetPrompt = getStepBudgetPromptSection(agent.config.steps);
+  if (!stepBudgetPrompt) {
+    return;
+  }
+  agent.config.prompt = appendPromptSections(
+    agent.config.prompt,
+    stepBudgetPrompt
+  );
+}
+function applyGeminiDefaultSteps(agent) {
+  if (!isSubagent(agent.name) || agent.config.steps !== void 0) {
+    return;
+  }
+  if (detectModelFamily(agent._modelArray ?? agent.config.model) !== "gemini") {
+    return;
+  }
+  agent.config.steps = GEMINI_DEFAULT_STEPS[agent.name];
+}
+function clonePermissionConfig(permission) {
+  if (typeof permission === "string") {
+    return permission;
+  }
+  return Object.fromEntries(
+    Object.entries(permission).map(([key, value]) => [
+      key,
+      value && typeof value === "object" && !Array.isArray(value) ? { ...value } : value
+    ])
+  );
+}
+function getBuiltinPermissionPreset(name) {
+  return clonePermissionConfig(BUILTIN_PERMISSION_PRESETS[name]);
+}
+function getExplicitPermissionOverride(override) {
+  return override?.permission;
+}
+function getPrimaryModelForPrompt(model) {
+  if (Array.isArray(model)) {
+    const first = model[0];
+    return typeof first === "string" ? first : first?.id;
+  }
+  return model;
+}
+function isSubagent(name) {
+  return SUBAGENT_NAMES.includes(name);
+}
+var SUBAGENT_FACTORIES = {
+  explorer: createExplorerAgent,
+  librarian: createLibrarianAgent,
+  oracle: createOracleAgent,
+  designer: createDesignerAgent,
+  quick: createQuickAgent,
+  deep: createDeepAgent
+};
+function createAgents(config) {
+  const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => {
+    const override = getAgentOverride(config, name);
+    const prompts = loadAgentPrompt(name, config?.preset);
+    const model = getPrimaryModelForPrompt(override?.model) ?? DEFAULT_MODELS[name];
+    return factory(model, prompts.prompt, prompts.appendPrompt);
+  });
+  const allSubAgents = protoSubAgents.map((agent) => {
+    const override = getAgentOverride(config, agent.name);
+    if (override) {
+      applyOverrides(agent, override);
+    }
+    applyGeminiDefaultSteps(agent);
+    applyStepBudgetPrompt(agent);
+    return agent;
+  });
+  const orchestratorOverride = getAgentOverride(config, "orchestrator");
+  const orchestratorPrompts = loadAgentPrompt("orchestrator", config?.preset);
+  const orchestrator = createOrchestratorAgent(
+    orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator,
+    orchestratorPrompts.prompt,
+    orchestratorPrompts.appendPrompt
+  );
+  if (orchestratorOverride) {
+    applyOverrides(orchestrator, orchestratorOverride);
+  }
+  applyStepBudgetPrompt(orchestrator);
+  return [orchestrator, ...allSubAgents];
+}
+function getAgentConfigs(config) {
+  const agents = createAgents(config);
+  return Object.fromEntries(
+    agents.map((agent) => {
+      const override = getAgentOverride(config, agent.name);
+      const sdkConfig = {
+        ...agent.config,
+        description: agent.description
+      };
+      const builtinPermission = isSubagent(agent.name) ? getBuiltinPermissionPreset(agent.name) : agent.name === "orchestrator" ? getBuiltinPermissionPreset("orchestrator") : void 0;
+      const explicitPermissionOverride = getExplicitPermissionOverride(override);
+      sdkConfig.permission = explicitPermissionOverride ?? agent.config.permission ?? builtinPermission;
+      if (isSubagent(agent.name)) {
+        sdkConfig.mode = "subagent";
+      } else if (agent.name === "orchestrator") {
+        sdkConfig.mode = "primary";
+      }
+      return [agent.name, sdkConfig];
+    })
+  );
+}
+
+// src/harness/adapters/opencode.ts
+var OPENCODE_CAPABILITIES = {
+  agentDefinitions: "supported",
+  delegatedExecution: "supported",
+  parallelDelegation: "supported",
+  runtimeHooks: "supported",
+  mcpConfiguration: "supported",
+  skillPackaging: "supported",
+  rolePermissions: "supported",
+  parentContextInjection: "supported",
+  memoryGovernanceEnforcement: "supported"
+};
+function renderOpenCodeAgentConfigs(config) {
+  return getAgentConfigs(config);
+}
+function hasOpenCodeConfig(context) {
+  return "config" in context;
+}
+var opencodeAdapter = {
+  id: "opencode",
+  displayName: "OpenCode",
+  capabilities: OPENCODE_CAPABILITIES,
+  render(context) {
+    const config = hasOpenCodeConfig(context) ? context.config : void 0;
+    const agents = renderOpenCodeAgentConfigs(config);
+    return {
+      harness: "opencode",
+      artifacts: [
+        {
+          harness: "opencode",
+          kind: "agent-config",
+          path: "opencode.agent.config.json",
+          description: "Current OpenCode AgentConfig output rendered through the harness adapter boundary.",
+          content: JSON.stringify(agents, null, 2)
+        }
+      ],
+      diagnostics: []
+    };
+  }
+};
+
+// src/utils/subprocess.ts
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "child_process";
+import { Readable } from "stream";
+function emptyReadableStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function toWebReadable(stream) {
+  if (!stream) {
+    return emptyReadableStream();
+  }
+  return Readable.toWeb(
+    stream
+  );
+}
+function fallbackStdin() {
+  return {
+    write: () => void 0,
+    end: () => void 0
+  };
+}
+function spawn(command, options = {}) {
+  const child = nodeSpawn(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [
+      options.stdin ?? "pipe",
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe"
+    ]
+  });
+  const managed = {
+    stdin: child.stdin ?? fallbackStdin(),
+    stdout: toWebReadable(child.stdout),
+    stderr: toWebReadable(child.stderr),
+    exited: new Promise((resolve) => {
+      child.on("exit", (code) => {
+        managed.exitCode = code;
+        resolve(code ?? 1);
+      });
+      child.on("error", () => {
+        managed.exitCode = 1;
+        resolve(1);
+      });
+    }),
+    exitCode: child.exitCode,
+    kill: () => {
+      child.kill();
+    }
+  };
+  return managed;
+}
+function spawnSync(command, options = {}) {
+  const result = nodeSpawnSync(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [
+      options.stdin ?? "ignore",
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe"
+    ]
+  });
+  return { exitCode: result.status };
+}
+
+// src/cli/system.ts
+import { statSync } from "fs";
+var cachedOpenCodePath = null;
+function getOpenCodePaths() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return [
+    // PATH (try this first)
+    "opencode",
+    // User local installations (Linux & macOS)
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    // System-wide installations
+    "/usr/local/bin/opencode",
+    "/opt/opencode/bin/opencode",
+    "/usr/bin/opencode",
+    "/bin/opencode",
+    // macOS specific
+    "/Applications/OpenCode.app/Contents/MacOS/opencode",
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    // Homebrew (macOS & Linux)
+    "/opt/homebrew/bin/opencode",
+    "/home/linuxbrew/.linuxbrew/bin/opencode",
+    `${home}/homebrew/bin/opencode`,
+    // macOS user Library
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    // Snap (Linux)
+    "/snap/bin/opencode",
+    "/var/snap/opencode/current/bin/opencode",
+    // Flatpak (Linux)
+    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    // Nix (Linux/macOS)
+    "/nix/store/opencode/bin/opencode",
+    `${home}/.nix-profile/bin/opencode`,
+    "/run/current-system/sw/bin/opencode",
+    // Cargo (Rust toolchain)
+    `${home}/.cargo/bin/opencode`,
+    // npm/npx global
+    `${home}/.npm-global/bin/opencode`,
+    "/usr/local/lib/node_modules/opencode/bin/opencode",
+    // Yarn global
+    `${home}/.yarn/bin/opencode`,
+    // PNPM
+    `${home}/.pnpm-global/bin/opencode`
+  ];
+}
+function resolveOpenCodePath() {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode") continue;
+    try {
+      const stat = statSync(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {
+    }
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    try {
+      const proc = spawn([opencodePath, "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        cachedOpenCodePath = opencodePath;
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function getOpenCodeVersion() {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const proc = spawn([opencodePath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return output.trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function getOpenCodePath() {
+  const path = resolveOpenCodePath();
+  return path === "opencode" ? null : path;
+}
+
+export {
+  createAgents,
+  renderOpenCodeAgentConfigs,
+  opencodeAdapter,
+  spawn,
+  spawnSync,
+  isOpenCodeInstalled,
+  getOpenCodeVersion,
+  getOpenCodePath
+};