cscec-super-code 0.0.53

package/README.md

@@ -0,0 +1,130 @@
+# Cscec Super Code
+
+> 🚀 将单一 AI 模型转变为协调的开发团队，让正确的模型做正确的事
+
+## 项目简介
+
+Cscec Super Code（简称 Csc）是一个突破性的 OpenCode 插件，它扩展了 Claude Code（OpenCode 分支）的能力，通过多智能体编排、生命周期钩子、工具系统和技能/命令/MCP 系统，为 AI 编程带来革命性的体验。
+
+### 核心理念
+- **多模型协作**：不是让一个模型做所有事情，而是让正确的模型做正确的事
+- **专业化分工**：11 个智能体各司其职，协同完成复杂任务
+- **知识共享**：构建公司内部知识库、技能库、命令库、MCP 库
+- **国产大模型优先**：优先使用国产大模型，更能理解中文需求
+
+## 核心特性
+
+| 特性 | 描述 |
+|------|------|
+| 🤖 **多智能体编排** | 11 个专业化 AI 智能体协同工作，包括 Yugong、Luban、Jiangshang、Laozi、Xuxiake 等 |
+| ⚡ **`ultrawork`** | 一键触发，所有智能体出动，任务完成前绝不罢休 |
+| 🚪 **IntentGate 意图门** | 分析用户真实意图，告别被字面意思误导的 AI 废话 |
+| 🔗 **基于哈希的编辑工具** | 通过 `LINE#ID` 内容哈希验证，0% 错误修改 |
+| 🛠️ **LSP + AST-Grep** | 工作区级别的重命名、构建前诊断、基于 AST 的重写 |
+| 🧠 **后台智能体** | 同时发射 5+ 个专家并行工作，保持上下文干净 |
+| 📚 **内置 MCP** | Exa (网络搜索)、Context7 (官方文档)、Grep.app (GitHub 源码搜索) |
+| 🔁 **Ralph Loop** | 自我引用闭环，达不到 100% 完成度绝不停止 |
+| ✅ **Todo 强制执行** | Agent 想要摸鱼？系统直接揪着领子拽回来 |
+| 💬 **注释审查员** | 剔除带有浓烈 AI 味的冗余注释，写出的代码像老练的高级工程师 |
+| 🖥️ **Tmux 集成** | 完整的交互式终端支持，跑 REPL、调试器、TUI 工具 |
+| 🔌 **Claude Code 兼容** | 无缝迁移现有的 Hooks、命令、技能、MCP 和插件 |
+| 🎯 **技能内嵌 MCP** | 技能自带其所需的 MCP 服务器，按需开启 |
+| 📋 **Suirenshi 规划师** | 动手写代码前，先通过访谈模式做好战略规划 |
+| 🔍 **`/init-deep`** | 生成树状 docs/ 文件系统，提升 Agent 理解力 |
+| 📚 **知识库系统** | 结构化知识存储与管理，为 AI 智能体提供强大的知识支持 |
+| 💾 **记忆系统** | 先进的记忆机制，使智能体能够在不同会话之间保持连续性 |
+
+## 智能体系统
+
+Cscec Super Code 拥有 11 个专业化 AI 智能体，每个智能体都针对特定任务进行了优化：
+
+| 智能体 | 职责 | 最佳模型 |
+|-------|------|----------|
+| **Yugong** | 主编排器，任务规划与分配 | GLM-5、Doubao 2.0 Pro、Claude Opus 4.6 |
+| **Luban** | 正牌工匠，目标导向执行 | GLM-5、Doubao Seek Code、DeepSeek V3.2 Speciale |
+| **Jiangshang** | 架构顾问，架构决策与代码审查 | Qwen3 Max Thinking、GLM-5、DeepSeek V3.2 Speciale |
+| **Laozi** | 文档专家，多仓库分析与文档查找 | Doubao 1.8、GLM-5、DeepSeek V3 |
+| **Xuxiake** | 代码库 grep，快速模式发现 | Qwen3 Coder、Doubao 1.8、GLM-5 |
+| **Multimodal-Looker** | 多模态视觉专家 | GLM-5、Doubao Seek Code、GLM-4.6v |
+| **Suirenshi** | 战略规划师，访谈模式与计划制定 | GLM-5、Doubao 2.0 Pro、Claude Opus 4.6 |
+| **Nuwa** | 需求分析与设计专家 | GLM-5、Qwen3 Max Thinking、Claude Opus 4.6 |
+| **Weizheng** | 快速修复专家，问题诊断与代码修复 | GLM-5、DeepSeek V3.2 Speciale、Qwen3 Max Thinking |
+| **Buzhoushan** | 任务编排专家，Todo 管理与工作流协调 | GLM-5、Qwen3 Coder、DeepSeek V3.2 Speciale |
+| **Yugong-Junior** | 轻量级编排器 | GLM-5、Doubao 1.8、Claude Sonnet 4.6 |
+
+## 技术架构
+
+Cscec Super Code 采用模块化架构，主要组件包括：
+
+1. **智能体系统**：11 个专业化 AI 智能体，协同完成复杂任务
+2. **钩子系统**：46 个生命周期钩子，在关键节点拦截和修改行为
+3. **工具系统**：26 个工具，扩展 AI 的能力边界
+4. **技能与命令系统**：灵活的知识和工具注入机制
+5. **MCP 系统**：三层 MCP 架构，提供外部工具访问能力
+6. **配置系统**：多级配置，支持项目级和用户级配置
+7. **知识库系统**：结构化知识存储与管理
+8. **记忆系统**：先进的记忆机制，保持会话连续性
+
+## 快速开始
+
+### 安装前提
+- **Node.js**：版本 18.0 或更高
+- **OpenCode**：最新版本
+- **Bun**（推荐）：版本 1.0 或更高
+- **Trae**（推荐）：最新版本，容易上手的 IDE
+
+### 安装步骤
+
+**一键安装（推荐）**：将以下提示词发送给 Trae 或你的 LLM Agent：
+
+```
+配置镜像仓库
+1、设置npm仓库位置
+npm config set registry https://devops.cscec.com/osc/repo/api/npm/cip-dc-npm-group/
+
+2、安装Cscec Super Code
+npm install -g cscec-super-code
+
+3、配置OpenCode插件
+在OpenCode配置文件中添加cscec-super-code插件
+```
+
+### 基本使用
+
+1. **启动项目**：打开 OpenCode 并加载项目
+2. **触发 ultrawork**：输入 `ultrawork`（或 `ulw`）命令
+3. **描述任务**：告诉 AI 你想要完成的任务
+4. **观察执行**：智能体团队会自动分工协作，完成任务
+
+## 配置与扩展
+
+### 配置文件
+
+Cscec Super Code 支持多级配置：
+- **项目级**：`.opencode/cscec-super-code.jsonc`
+- **用户级**：`~/.config/opencode/cscec-super-code.jsonc`
+
+### 扩展开发
+
+你可以通过以下方式扩展 Cscec Super Code：
+- **添加新智能体**：在 `src/agents/` 目录中创建新智能体
+- **添加新钩子**：在 `src/hooks/` 目录中创建新钩子
+- **添加新工具**：在 `src/tools/` 目录中创建新工具
+- **添加新技能**：在 `.opencode/skills/` 目录中创建新技能
+- **添加新 MCP**：在 `src/mcp/` 目录中创建新 MCP
+
+## 详细文档
+
+- **[技术指南](docs/技术指南.md)**：详细的技术文档，包含使用指南、开发指南和未来规划
+- **[安装指南](docs/guide/installation.md)**：详细的安装步骤
+- **[智能体模型匹配](docs/guide/agent-model-matching.md)**：智能体与模型的匹配关系
+- **[编排指南](docs/guide/orchestration.md)**：智能体如何协作
+- **[配置参考](docs/reference/configuration.md)**：配置选项参考
+- **[特性文档](docs/reference/features.md)**：详细的特性说明
+
+### 可优化方向
+- **新智能体**：定义特定领域的专业智能体
+- **新技能**：创建行业/技术特定技能包
+- **新 MCP**：集成更多外部工具
+- **文档**：改进文档、翻译
+- **测试**：编写测试用例

package/bin/cscec-super-code.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+// bin/cscec-super-code.js
+// Wrapper script that detects platform and spawns the correct binary
+
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { getPlatformPackageCandidates, getBinaryPath } from "./platform.js";
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Detect libc family on Linux
+ * @returns {string | null} 'glibc', 'musl', or null if detection fails
+ */
+function getLibcFamily() {
+  if (process.platform !== "linux") {
+    return undefined; // Not needed on non-Linux
+  }
+  
+  try {
+    const detectLibc = require("detect-libc");
+    return detectLibc.familySync();
+  } catch {
+    // detect-libc not available
+    return null;
+  }
+}
+
+function supportsAvx2() {
+  if (process.arch !== "x64") {
+    return null;
+  }
+
+  if (process.env.OH_MY_OPENCODE_FORCE_BASELINE === "1") {
+    return false;
+  }
+
+  if (process.platform === "linux") {
+    try {
+      const cpuInfo = readFileSync("/proc/cpuinfo", "utf8").toLowerCase();
+      return cpuInfo.includes("avx2");
+    } catch {
+      return null;
+    }
+  }
+
+  if (process.platform === "darwin") {
+    const probe = spawnSync("sysctl", ["-n", "machdep.cpu.leaf7_features"], {
+      encoding: "utf8",
+    });
+
+    if (probe.error || probe.status !== 0) {
+      return null;
+    }
+
+    return probe.stdout.toUpperCase().includes("AVX2");
+  }
+
+  return null;
+}
+
+function getSignalExitCode(signal) {
+  const signalCodeByName = {
+    SIGINT: 2,
+    SIGILL: 4,
+    SIGKILL: 9,
+    SIGTERM: 15,
+  };
+
+  return 128 + (signalCodeByName[signal] ?? 1);
+}
+
+function main() {
+  const { platform, arch } = process;
+  const libcFamily = getLibcFamily();
+  const avx2Supported = supportsAvx2();
+  
+  let packageCandidates;
+  try {
+    packageCandidates = getPlatformPackageCandidates({
+      platform,
+      arch,
+      libcFamily,
+      preferBaseline: avx2Supported === false,
+    });
+  } catch (error) {
+    console.error(`\ncscec-super-code: ${error.message}\n`);
+    process.exit(1);
+  }
+
+  const resolvedBinaries = packageCandidates
+    .map((pkg) => {
+      try {
+        return { pkg, binPath: require.resolve(getBinaryPath(pkg, platform)) };
+      } catch {
+        return null;
+      }
+    })
+    .filter((entry) => entry !== null);
+
+  if (resolvedBinaries.length === 0) {
+    console.error(`\ncscec-super-code: Platform binary not installed.`);
+    console.error(`\nYour platform: ${platform}-${arch}${libcFamily === "musl" ? "-musl" : ""}`);
+    console.error(`Expected packages (in order): ${packageCandidates.join(", ")}`);
+    console.error(`\nTo fix, run:`);
+    console.error(`  npm install ${packageCandidates[0]}\n`);
+    process.exit(1);
+  }
+
+  for (let index = 0; index < resolvedBinaries.length; index += 1) {
+    const currentBinary = resolvedBinaries[index];
+    const hasFallback = index < resolvedBinaries.length - 1;
+    const result = spawnSync(currentBinary.binPath, process.argv.slice(2), {
+      stdio: "inherit",
+    });
+
+    if (result.error) {
+      if (hasFallback) {
+        continue;
+      }
+
+      console.error(`\ncscec-super-code: Failed to execute binary.`);
+      console.error(`Error: ${result.error.message}\n`);
+      process.exit(2);
+    }
+
+    if (result.signal === "SIGILL" && hasFallback) {
+      continue;
+    }
+
+    if (result.signal) {
+      process.exit(getSignalExitCode(result.signal));
+    }
+
+    process.exit(result.status ?? 1);
+  }
+
+  process.exit(1);
+}
+
+main();

package/bin/platform.d.ts

@@ -0,0 +1,14 @@
+export declare function getPlatformPackage(options: {
+  platform: string;
+  arch: string;
+  libcFamily?: string | null;
+}): string;
+
+export declare function getPlatformPackageCandidates(options: {
+  platform: string;
+  arch: string;
+  libcFamily?: string | null;
+  preferBaseline?: boolean;
+}): string[];
+
+export declare function getBinaryPath(pkg: string, platform: string): string;

package/bin/platform.js

@@ -0,0 +1,82 @@
+// bin/platform.js
+// Shared platform detection module - used by wrapper and postinstall
+
+/**
+ * Get the platform-specific package name
+ * @param {{ platform: string, arch: string, libcFamily?: string | null }} options
+ * @returns {string} Package name like "cscec-super-code-darwin-arm64"
+ * @throws {Error} If libc cannot be detected on Linux
+ */
+export function getPlatformPackage({ platform, arch, libcFamily }) {
+  let suffix = "";
+  if (platform === "linux") {
+    if (libcFamily === null || libcFamily === undefined) {
+      throw new Error(
+        "Could not detect libc on Linux. " +
+        "Please ensure detect-libc is installed or report this issue."
+      );
+    }
+    if (libcFamily === "musl") {
+      suffix = "-musl";
+    }
+  }
+  
+  // Map platform names: win32 -> windows (for package name)
+  const os = platform === "win32" ? "windows" : platform;
+  return `cscec-super-code-${os}-${arch}${suffix}`;
+}
+
+/** @param {{ platform: string, arch: string, libcFamily?: string | null, preferBaseline?: boolean }} options */
+export function getPlatformPackageCandidates({ platform, arch, libcFamily, preferBaseline = false }) {
+  const primaryPackage = getPlatformPackage({ platform, arch, libcFamily });
+  const baselinePackage = getBaselinePlatformPackage({ platform, arch, libcFamily });
+
+  if (!baselinePackage) {
+    return [primaryPackage];
+  }
+
+  return preferBaseline ? [baselinePackage, primaryPackage] : [primaryPackage, baselinePackage];
+}
+
+/** @param {{ platform: string, arch: string, libcFamily?: string | null }} options */
+function getBaselinePlatformPackage({ platform, arch, libcFamily }) {
+  if (arch !== "x64") {
+    return null;
+  }
+
+  if (platform === "darwin") {
+    return "cscec-super-code-darwin-x64-baseline";
+  }
+
+  if (platform === "win32") {
+    return "cscec-super-code-windows-x64-baseline";
+  }
+
+  if (platform === "linux") {
+    if (libcFamily === null || libcFamily === undefined) {
+      throw new Error(
+        "Could not detect libc on Linux. " +
+        "Please ensure detect-libc is installed or report this issue."
+      );
+    }
+
+    if (libcFamily === "musl") {
+      return "cscec-super-code-linux-x64-musl-baseline";
+    }
+
+    return "cscec-super-code-linux-x64-baseline";
+  }
+
+  return null;
+}
+
+/**
+ * Get the path to the binary within a platform package
+ * @param {string} pkg Package name
+ * @param {string} platform Process platform
+ * @returns {string} Relative path like "cscec-super-code-darwin-arm64/bin/cscec-super-code"
+ */
+export function getBinaryPath(pkg, platform) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return `${pkg}/bin/cscec-super-code${ext}`;
+}

package/bin/platform.test.ts

@@ -0,0 +1,203 @@
+// bin/platform.test.ts
+import { describe, expect, test } from "bun:test";
+import { getBinaryPath, getPlatformPackage, getPlatformPackageCandidates } from "./platform.js";
+
+describe("getPlatformPackage", () => {
+  // #region Darwin platforms
+  test("returns darwin-arm64 for macOS ARM64", () => {
+    // #given macOS ARM64 platform
+    const input = { platform: "darwin", arch: "arm64" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("cscec-super-code-darwin-arm64");
+  });
+
+  test("returns darwin-x64 for macOS Intel", () => {
+    // #given macOS x64 platform
+    const input = { platform: "darwin", arch: "x64" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("cscec-super-code-darwin-x64");
+  });
+  // #endregion
+
+  // #region Linux glibc platforms
+  test("returns linux-x64 for Linux x64 with glibc", () => {
+    // #given Linux x64 with glibc
+    const input = { platform: "linux", arch: "x64", libcFamily: "glibc" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("cscec-super-code-linux-x64");
+  });
+
+  test("returns linux-arm64 for Linux ARM64 with glibc", () => {
+    // #given Linux ARM64 with glibc
+    const input = { platform: "linux", arch: "arm64", libcFamily: "glibc" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("cscec-super-code-linux-arm64");
+  });
+  // #endregion
+
+  // #region Linux musl platforms
+  test("returns linux-x64-musl for Alpine x64", () => {
+    // #given Linux x64 with musl (Alpine)
+    const input = { platform: "linux", arch: "x64", libcFamily: "musl" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name with musl suffix
+    expect(result).toBe("cscec-super-code-linux-x64-musl");
+  });
+
+  test("returns linux-arm64-musl for Alpine ARM64", () => {
+    // #given Linux ARM64 with musl (Alpine)
+    const input = { platform: "linux", arch: "arm64", libcFamily: "musl" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name with musl suffix
+    expect(result).toBe("cscec-super-code-linux-arm64-musl");
+  });
+  // #endregion
+
+  // #region Windows platform
+  test("returns windows-x64 for Windows", () => {
+    // #given Windows x64 platform (win32 is Node's platform name)
+    const input = { platform: "win32", arch: "x64" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name with 'windows' not 'win32'
+    expect(result).toBe("cscec-super-code-windows-x64");
+  });
+  // #endregion
+
+  // #region Error cases
+  test("throws error for Linux with null libcFamily", () => {
+    // #given Linux platform with null libc detection
+    const input = { platform: "linux", arch: "x64", libcFamily: null };
+
+    // #when getting platform package
+    // #then throws descriptive error
+    expect(() => getPlatformPackage(input)).toThrow("Could not detect libc");
+  });
+
+  test("throws error for Linux with undefined libcFamily", () => {
+    // #given Linux platform with undefined libc
+    const input = { platform: "linux", arch: "x64", libcFamily: undefined };
+
+    // #when getting platform package
+    // #then throws descriptive error
+    expect(() => getPlatformPackage(input)).toThrow("Could not detect libc");
+  });
+  // #endregion
+});
+
+describe("getBinaryPath", () => {
+  test("returns path without .exe for Unix platforms", () => {
+    // #given Unix platform package
+    const pkg = "cscec-super-code-darwin-arm64";
+    const platform = "darwin";
+
+    // #when getting binary path
+    const result = getBinaryPath(pkg, platform);
+
+    // #then returns path without extension
+    expect(result).toBe("cscec-super-code-darwin-arm64/bin/cscec-super-code");
+  });
+
+  test("returns path with .exe for Windows", () => {
+    // #given Windows platform package
+    const pkg = "cscec-super-code-windows-x64";
+    const platform = "win32";
+
+    // #when getting binary path
+    const result = getBinaryPath(pkg, platform);
+
+    // #then returns path with .exe extension
+    expect(result).toBe("cscec-super-code-windows-x64/bin/cscec-super-code.exe");
+  });
+
+  test("returns path without .exe for Linux", () => {
+    // #given Linux platform package
+    const pkg = "cscec-super-code-linux-x64";
+    const platform = "linux";
+
+    // #when getting binary path
+    const result = getBinaryPath(pkg, platform);
+
+    // #then returns path without extension
+    expect(result).toBe("cscec-super-code-linux-x64/bin/cscec-super-code");
+  });
+});
+
+describe("getPlatformPackageCandidates", () => {
+  test("returns x64 and baseline candidates for Linux glibc", () => {
+    // #given Linux x64 with glibc
+    const input = { platform: "linux", arch: "x64", libcFamily: "glibc" };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then returns modern first then baseline fallback
+    expect(result).toEqual([
+      "cscec-super-code-linux-x64",
+      "cscec-super-code-linux-x64-baseline",
+    ]);
+  });
+
+  test("returns x64 musl and baseline candidates for Linux musl", () => {
+    // #given Linux x64 with musl
+    const input = { platform: "linux", arch: "x64", libcFamily: "musl" };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then returns musl modern first then musl baseline fallback
+    expect(result).toEqual([
+      "cscec-super-code-linux-x64-musl",
+      "cscec-super-code-linux-x64-musl-baseline",
+    ]);
+  });
+
+  test("returns baseline first when preferBaseline is true", () => {
+    // #given Windows x64 and baseline preference
+    const input = { platform: "win32", arch: "x64", preferBaseline: true };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then baseline package is preferred first
+    expect(result).toEqual([
+      "cscec-super-code-windows-x64-baseline",
+      "cscec-super-code-windows-x64",
+    ]);
+  });
+
+  test("returns only one candidate for ARM64", () => {
+    // #given non-x64 platform
+    const input = { platform: "linux", arch: "arm64", libcFamily: "glibc" };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then baseline fallback is not included
+    expect(result).toEqual(["cscec-super-code-linux-arm64"]);
+  });
+});

package/dist/agents/agent-builder.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "./types";
+import type { CategoriesConfig, GitMasterConfig } from "../config/schema";
+import type { BrowserAutomationProvider } from "../config/schema";
+export type AgentSource = AgentFactory | AgentConfig;
+export declare function isFactory(source: AgentSource): source is AgentFactory;
+export declare function buildAgent(source: AgentSource, model: string, categories?: CategoriesConfig, gitMasterConfig?: GitMasterConfig, browserProvider?: BrowserAutomationProvider, disabledSkills?: Set<string>): AgentConfig;

package/dist/agents/builtin-agents/agent-overrides.d.ts

@@ -0,0 +1,12 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentOverrideConfig } from "../types";
+import type { CategoryConfig } from "../../config/schema";
+/**
+ * Expands a category reference from an agent override into concrete config properties.
+ * Category properties are applied unconditionally (overwriting factory defaults),
+ * because the user's chosen category should take priority over factory base values.
+ * Direct override properties applied later via mergeAgentConfig() will supersede these.
+ */
+export declare function applyCategoryOverride(config: AgentConfig, categoryName: string, mergedCategories: Record<string, CategoryConfig>): AgentConfig;
+export declare function mergeAgentConfig(base: AgentConfig, override: AgentOverrideConfig, directory?: string): AgentConfig;
+export declare function applyOverrides(config: AgentConfig, override: AgentOverrideConfig | undefined, mergedCategories: Record<string, CategoryConfig>, directory?: string): AgentConfig;

package/dist/agents/builtin-agents/available-skills.d.ts

@@ -0,0 +1,4 @@
+import type { AvailableSkill } from "../dynamic-agent-prompt-builder";
+import type { BrowserAutomationProvider } from "../../config/schema";
+import type { LoadedSkill } from "../../features/opencode-skill-loader/types";
+export declare function buildAvailableSkills(discoveredSkills: LoadedSkill[], browserProvider?: BrowserAutomationProvider, disabledSkills?: Set<string>): AvailableSkill[];

package/dist/agents/builtin-agents/buzhoushan-agent.d.ts

@@ -0,0 +1,17 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentOverrides } from "../types";
+import type { CategoriesConfig, CategoryConfig } from "../../config/schema";
+import type { AvailableAgent, AvailableSkill } from "../dynamic-agent-prompt-builder";
+export declare function maybeCreateBuzhoushanConfig(input: {
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    uiSelectedModel?: string;
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+    availableAgents: AvailableAgent[];
+    availableSkills: AvailableSkill[];
+    mergedCategories: Record<string, CategoryConfig>;
+    directory?: string;
+    userCategories?: CategoriesConfig;
+    useTaskSystem?: boolean;
+}): AgentConfig | undefined;

package/dist/agents/builtin-agents/environment-context.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+type ApplyEnvironmentContextOptions = {
+    disableOmoEnv?: boolean;
+};
+export declare function applyEnvironmentContext(config: AgentConfig, directory?: string, options?: ApplyEnvironmentContextOptions): AgentConfig;
+export {};

package/dist/agents/builtin-agents/general-agents.d.ts

@@ -0,0 +1,24 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { BuiltinAgentName, AgentOverrides, AgentPromptMetadata } from "../types";
+import type { CategoryConfig, GitMasterConfig } from "../../config/schema";
+import type { BrowserAutomationProvider } from "../../config/schema";
+import type { AvailableAgent } from "../dynamic-agent-prompt-builder";
+export declare function collectPendingBuiltinAgents(input: {
+    agentSources: Record<BuiltinAgentName, import("../agent-builder").AgentSource>;
+    agentMetadata: Partial<Record<BuiltinAgentName, AgentPromptMetadata>>;
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    directory?: string;
+    systemDefaultModel?: string;
+    mergedCategories: Record<string, CategoryConfig>;
+    gitMasterConfig?: GitMasterConfig;
+    browserProvider?: BrowserAutomationProvider;
+    uiSelectedModel?: string;
+    availableModels: Set<string>;
+    disabledSkills?: Set<string>;
+    useTaskSystem?: boolean;
+    disableOmoEnv?: boolean;
+}): {
+    pendingAgentConfigs: Map<string, AgentConfig>;
+    availableAgents: AvailableAgent[];
+};

package/dist/agents/builtin-agents/luban-agent.d.ts

@@ -0,0 +1,18 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentOverrides } from "../types";
+import type { CategoryConfig } from "../../config/schema";
+import type { AvailableAgent, AvailableCategory, AvailableSkill } from "../dynamic-agent-prompt-builder";
+export declare function maybeCreateLubanConfig(input: {
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+    isFirstRunNoCache: boolean;
+    availableAgents: AvailableAgent[];
+    availableSkills: AvailableSkill[];
+    availableCategories: AvailableCategory[];
+    mergedCategories: Record<string, CategoryConfig>;
+    directory?: string;
+    useTaskSystem: boolean;
+    disableOmoEnv?: boolean;
+}): AgentConfig | undefined;