@zcy2nn/agent-forge 1.0.1

package/dist/cli/install.d.ts

@@ -0,0 +1,2 @@
+import type { InstallArgs } from './types';
+export declare function install(args: InstallArgs): Promise<number>;

package/dist/cli/migration.d.ts

@@ -0,0 +1,46 @@
+/** Result of a migration attempt. */
+export interface MigrationResult {
+    /** Whether a legacy config was detected. */
+    detected: boolean;
+    /** Whether the migration was performed. */
+    migrated: boolean;
+    /** Path to the new config file, if migrated. */
+    newPath?: string;
+    /** Path to the legacy config file that was found. */
+    legacyPath?: string;
+    /** Error message if migration failed. */
+    error?: string;
+}
+/**
+ * Get all possible legacy config file paths (json and jsonc).
+ */
+export declare function getLegacyConfigPaths(): string[];
+/**
+ * Detect whether a legacy `oh-my-opencode-slim.json` config exists.
+ * Returns the path if found, or undefined.
+ */
+export declare function detectLegacyConfig(): string | undefined;
+/**
+ * Check if a config object contains any legacy agent names
+ * in its presets or agents sections.
+ */
+export declare function hasLegacyAgentNames(config: Record<string, unknown>): boolean;
+/**
+ * Migrate agent names in a config object.
+ *
+ * - Renames primary mapping keys (explorer→researcher, oracle→reviewer,
+ *   designer→implementer).
+ * - For secondary mappings (librarian→researcher, fixer→implementer),
+ *   only applies if the primary mapping target doesn't already exist.
+ * - Removes observer entries entirely.
+ * - Preserves all non-agent config keys unchanged.
+ */
+export declare function migrateAgentNames(config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Perform the full migration:
+ * 1. Read legacy config
+ * 2. Migrate agent names
+ * 3. Write to `agent-forge.json`
+ * 4. Rename legacy file to `.bak`
+ */
+export declare function performMigration(legacyPath: string): MigrationResult;

package/dist/cli/model-key-normalization.d.ts

@@ -0,0 +1 @@
+export declare function buildModelKeyAliases(input: string): string[];

package/dist/cli/paths.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Get the OpenCode plugin config directory.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (custom OpenCode directory)
+ * 2. XDG_CONFIG_HOME/opencode
+ * 3. ~/.config/opencode
+ */
+export declare function getConfigDir(): string;
+/**
+ * Get OpenCode config directories in read/search order.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (if set)
+ * 2. XDG_CONFIG_HOME/opencode or ~/.config/opencode
+ *
+ * Duplicate entries are removed.
+ */
+export declare function getConfigSearchDirs(): string[];
+export declare function getOpenCodeConfigPaths(): string[];
+export declare function getConfigJson(): string;
+export declare function getConfigJsonc(): string;
+export declare function getLiteConfig(): string;
+export declare function getLiteConfigJsonc(): string;
+export declare function getTuiConfig(): string;
+export declare function getTuiConfigJsonc(): string;
+export declare function getExistingLiteConfigPath(): string;
+export declare function getExistingTuiConfigPath(): string;
+export declare function getExistingConfigPath(): string;
+export declare function ensureConfigDir(): void;
+export declare function ensureTuiConfigDir(): void;
+/**
+ * Ensure the directory for OpenCode's main config file exists.
+ */
+export declare function ensureOpenCodeConfigDir(): void;

package/dist/cli/providers.d.ts

@@ -0,0 +1,99 @@
+import type { InstallConfig } from './types';
+export declare const GENERATED_PRESETS: readonly ["openai", "opencode-go"];
+export declare const MODEL_MAPPINGS: {
+    readonly openai: {
+        readonly orchestrator: {
+            readonly model: "openai/gpt-5.5";
+        };
+        readonly reviewer: {
+            readonly model: "openai/gpt-5.5";
+            readonly variant: "high";
+        };
+        readonly researcher: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+        readonly implementer: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+    };
+    readonly kimi: {
+        readonly orchestrator: {
+            readonly model: "kimi-for-coding/k2p5";
+        };
+        readonly reviewer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "high";
+        };
+        readonly researcher: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly implementer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+    };
+    readonly copilot: {
+        readonly orchestrator: {
+            readonly model: "github-copilot/claude-opus-4.6";
+        };
+        readonly reviewer: {
+            readonly model: "github-copilot/claude-opus-4.6";
+            readonly variant: "high";
+        };
+        readonly researcher: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly implementer: {
+            readonly model: "github-copilot/claude-sonnet-4.6";
+            readonly variant: "low";
+        };
+    };
+    readonly 'zai-plan': {
+        readonly orchestrator: {
+            readonly model: "zai-coding-plan/glm-5";
+        };
+        readonly reviewer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "high";
+        };
+        readonly researcher: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly implementer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+    };
+    readonly 'opencode-go': {
+        readonly orchestrator: {
+            readonly model: "opencode-go/glm-5.1";
+        };
+        readonly reviewer: {
+            readonly model: "opencode-go/deepseek-v4-pro";
+            readonly variant: "max";
+        };
+        readonly council: {
+            readonly model: "opencode-go/deepseek-v4-pro";
+            readonly variant: "high";
+        };
+        readonly researcher: {
+            readonly model: "opencode-go/minimax-m2.7";
+        };
+        readonly implementer: {
+            readonly model: "opencode-go/deepseek-v4-flash";
+            readonly variant: "high";
+        };
+    };
+};
+export type PresetName = keyof typeof MODEL_MAPPINGS;
+export type GeneratedPresetName = (typeof GENERATED_PRESETS)[number];
+export declare function isPresetName(value: string): value is PresetName;
+export declare function getPresetNames(): PresetName[];
+export declare function isGeneratedPresetName(value: string): value is GeneratedPresetName;
+export declare function getGeneratedPresetNames(): GeneratedPresetName[];
+export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;

package/dist/cli/skills.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A recommended skill to install via `npx skills add`.
+ */
+export interface RecommendedSkill {
+    /** Human-readable name for prompts */
+    name: string;
+    /** GitHub repo URL for `npx skills add` */
+    repo: string;
+    /** Skill name within the repo (--skill flag) */
+    skillName: string;
+    /** List of agents that should auto-allow this skill */
+    allowedAgents: string[];
+    /** Description shown to user during install */
+    description: string;
+    /** Optional commands to run after the skill is added */
+    postInstallCommands?: string[];
+}
+/**
+ * A skill that is managed externally (e.g. user-installed) and needs
+ * permission grants but is NOT installed by this plugin's CLI.
+ */
+export interface PermissionOnlySkill {
+    /** Skill name — must match the name OpenCode uses for permission checks */
+    name: string;
+    /** List of agents that should auto-allow this skill */
+    allowedAgents: string[];
+    /** Human-readable description (for documentation only) */
+    description: string;
+}
+/**
+ * List of recommended skills.
+ * Add new skills here to include them in the installation flow.
+ */
+export declare const RECOMMENDED_SKILLS: RecommendedSkill[];
+/**
+ * Skills managed externally (not installed by this plugin's CLI).
+ * Entries here only affect agent permission grants — nothing is installed.
+ */
+export declare const PERMISSION_ONLY_SKILLS: PermissionOnlySkill[];
+/**
+ * Install a skill using `npx skills add`.
+ * @param skill - The skill to install
+ * @returns True if installation succeeded, false otherwise
+ */
+export declare function installSkill(skill: RecommendedSkill): boolean;
+/**
+ * Get permission presets for a specific agent based on recommended skills.
+ * @param agentName - The name of the agent
+ * @param skillList - Optional explicit list of skills to allow (overrides recommendations)
+ * @returns Permission rules for the skill permission type
+ */
+export declare function getSkillPermissionsForAgent(agentName: string, skillList?: string[]): Record<string, 'allow' | 'ask' | 'deny'>;

package/dist/cli/system.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveOpenCodePath(): string;
+export declare function isOpenCodeInstalled(): Promise<boolean>;
+export declare function isTmuxInstalled(): Promise<boolean>;
+export declare function getOpenCodeVersion(): Promise<string | null>;
+export declare function getOpenCodePath(): string | null;
+export declare function fetchLatestVersion(packageName: string): Promise<string | null>;

package/dist/cli/types.d.ts

@@ -0,0 +1,40 @@
+export type BooleanArg = 'yes' | 'no';
+export interface InstallArgs {
+    tui: boolean;
+    skills?: BooleanArg;
+    preset?: string;
+    dryRun?: boolean;
+    reset?: boolean;
+}
+export interface OpenCodeConfig {
+    plugin?: unknown[];
+    provider?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface InstallConfig {
+    hasTmux: boolean;
+    installSkills: boolean;
+    installCustomSkills: boolean;
+    preset?: string;
+    promptForStar?: boolean;
+    dryRun?: boolean;
+    reset: boolean;
+}
+export interface ConfigMergeResult {
+    success: boolean;
+    configPath: string;
+    error?: string;
+}
+export interface DetectedConfig {
+    isInstalled: boolean;
+    hasKimi: boolean;
+    hasOpenAI: boolean;
+    hasAnthropic?: boolean;
+    hasCopilot?: boolean;
+    hasZaiPlan?: boolean;
+    hasAntigravity: boolean;
+    hasChutes?: boolean;
+    hasOpencodeZen: boolean;
+    hasTmux: boolean;
+}

package/dist/config/agent-mcps.d.ts

@@ -0,0 +1,15 @@
+import { type AgentName, type PluginConfig } from '.';
+/** Default MCPs per agent - "*" means all MCPs, "!item" excludes specific MCPs */
+export declare const DEFAULT_AGENT_MCPS: Record<AgentName, string[]>;
+/**
+ * Parse a list with wildcard and exclusion syntax.
+ */
+export declare function parseList(items: string[], allAvailable: string[]): string[];
+/**
+ * Get available MCP names from schema and config.
+ */
+export declare function getAvailableMcpNames(config?: PluginConfig): string[];
+/**
+ * Get the MCP list for an agent (from config or defaults).
+ */
+export declare function getAgentMcpList(agentName: string, config?: PluginConfig): string[];

package/dist/config/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const SUBAGENT_NAMES: readonly ["researcher", "reviewer", "implementer", "council", "councillor"];
+export declare const ORCHESTRATOR_NAME: "orchestrator";
+export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "researcher", "reviewer", "implementer", "council", "councillor"];
+export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+export declare const ORCHESTRATABLE_AGENTS: readonly ["researcher", "reviewer", "implementer", "council"];
+/** Agents that cannot be disabled even if listed in disabled_agents config. */
+export declare const PROTECTED_AGENTS: Set<string>;
+/**
+ * Get the list of orchestratable agents, excluding any disabled agents.
+ * This is used for delegation validation at runtime.
+ */
+export declare function getOrchestratableAgents(disabledAgents?: Set<string>): string[];
+export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
+export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
+export declare const POLL_INTERVAL_MS = 500;
+export declare const POLL_INTERVAL_SLOW_MS = 1000;
+export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare const MAX_POLL_TIME_MS: number;
+export declare const FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
+export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+export declare const PHASE_REMINDER_TEXT = "!IMPORTANT! Recall the workflow rules:\nUnderstand \u2192 choose the best parallelized path based on your capabilities and agents delegation rules \u2192 recall session reuse rules \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it !END!";
+export declare const TMUX_SPAWN_DELAY_MS = 500;
+export declare const COUNCILLOR_STAGGER_MS = 250;
+export declare const STABLE_POLLS_THRESHOLD = 3;
+/** Agents that are disabled by default. Users must explicitly enable them
+ *  by removing from disabled_agents and configuring an appropriate model. */
+export declare const DEFAULT_DISABLED_AGENTS: string[];

package/dist/config/council-schema.d.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+/**
+ * Configuration for a single councillor within a preset.
+ * Each councillor is an independent LLM that processes the same prompt.
+ *
+ * Councillors run as agent sessions with read-only codebase access
+ * (read, glob, grep, lsp, list). They can examine the codebase but
+ * cannot modify files or spawn subagents.
+ */
+export declare const CouncillorConfigSchema: z.ZodObject<{
+    model: z.ZodString;
+    variant: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CouncillorConfig = z.infer<typeof CouncillorConfigSchema>;
+/**
+ * A named preset grouping several councillors.
+ *
+ * All keys are treated as councillor names mapping to councillor configs.
+ * The reserved key `"master"` is silently ignored (legacy from when
+ * council-master was a separate agent).
+ */
+export declare const CouncilPresetSchema: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>, z.ZodTransform<Record<string, {
+    model: string;
+    variant?: string | undefined;
+    prompt?: string | undefined;
+}>, Record<string, Record<string, unknown>>>>;
+export type CouncilPreset = z.infer<typeof CouncilPresetSchema>;
+/**
+ * Execution mode for councillors.
+ * - parallel: Run all councillors concurrently (default, fastest for multi-model systems)
+ * - serial: Run councillors one at a time (required for single-model systems to avoid conflicts)
+ */
+export declare const CouncillorExecutionModeSchema: z.ZodDefault<z.ZodEnum<{
+    parallel: "parallel";
+    serial: "serial";
+}>>;
+/**
+ * Top-level council configuration.
+ *
+ * Example JSONC:
+ * ```jsonc
+ * {
+ *   "council": {
+ *     "presets": {
+ *       "default": {
+ *         "alpha": { "model": "openai/gpt-5.4-mini" },
+ *         "beta":  { "model": "openai/gpt-5.3-codex" },
+ *         "gamma": { "model": "google/gemini-3-pro" }
+ *       }
+ *     },
+ *     "timeout": 180000,
+ *     "councillor_execution_mode": "serial"
+ *   }
+ * }
+ * ```
+ */
+export declare const CouncilConfigSchema: z.ZodPipe<z.ZodObject<{
+    presets: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>, z.ZodTransform<Record<string, {
+        model: string;
+        variant?: string | undefined;
+        prompt?: string | undefined;
+    }>, Record<string, Record<string, unknown>>>>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    default_preset: z.ZodDefault<z.ZodString>;
+    councillor_execution_mode: z.ZodDefault<z.ZodEnum<{
+        parallel: "parallel";
+        serial: "serial";
+    }>>;
+    councillor_retries: z.ZodDefault<z.ZodNumber>;
+    master: z.ZodOptional<z.ZodUnknown>;
+    master_timeout: z.ZodOptional<z.ZodUnknown>;
+    master_fallback: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodTransform<{
+    presets: Record<string, Record<string, {
+        model: string;
+        variant?: string | undefined;
+        prompt?: string | undefined;
+    }>>;
+    timeout: number;
+    default_preset: string;
+    councillor_execution_mode: "parallel" | "serial";
+    councillor_retries: number;
+    _deprecated: string[] | undefined;
+    _legacyMasterModel: string | undefined;
+}, {
+    presets: Record<string, Record<string, {
+        model: string;
+        variant?: string | undefined;
+        prompt?: string | undefined;
+    }>>;
+    timeout: number;
+    default_preset: string;
+    councillor_execution_mode: "parallel" | "serial";
+    councillor_retries: number;
+    master?: unknown;
+    master_timeout?: unknown;
+    master_fallback?: unknown;
+}>>;
+export type CouncilConfig = z.infer<typeof CouncilConfigSchema>;
+export type CouncillorExecutionMode = z.infer<typeof CouncillorExecutionModeSchema>;
+/**
+ * A sensible default council configuration that users can copy into their
+ * opencode.jsonc. Provides a 3-councillor preset using common models.
+ *
+ * Users should replace models with ones they have access to.
+ *
+ * ```jsonc
+ * "council": DEFAULT_COUNCIL_CONFIG
+ * ```
+ */
+export declare const DEFAULT_COUNCIL_CONFIG: z.input<typeof CouncilConfigSchema>;
+/**
+ * Result of a council session.
+ */
+export interface CouncilResult {
+    success: boolean;
+    result?: string;
+    error?: string;
+    councillorResults: Array<{
+        name: string;
+        model: string;
+        status: 'completed' | 'failed' | 'timed_out';
+        result?: string;
+        error?: string;
+    }>;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './council-schema';
+export { deepMerge, loadAgentPrompt, loadPluginConfig } from './loader';
+export * from './schema';
+export { getAgentOverride, getCustomAgentNames } from './utils';

package/dist/config/loader.d.ts

@@ -0,0 +1,57 @@
+import { type PluginConfig } from './schema';
+/**
+ * Find plugin config paths (user and project) for a given directory.
+ * User config uses getConfigSearchDirs() for lookup.
+ * Project config uses <directory>/.opencode/agent-forge.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @returns Object with userConfigPath and projectConfigPath (null if not found)
+ */
+export declare function findPluginConfigPaths(directory: string): {
+    userConfigPath: string | null;
+    projectConfigPath: string | null;
+};
+/**
+ * Merge two plugin configs using the loader's merge rules.
+ * Project/override takes precedence over base.
+ */
+export declare function mergePluginConfigs(base: PluginConfig, override: PluginConfig): PluginConfig;
+/**
+ * Recursively merge two objects, with override values taking precedence.
+ * For nested objects, merges recursively. For arrays and primitives, override replaces base.
+ *
+ * @param base - Base object to merge into
+ * @param override - Override object whose values take precedence
+ * @returns Merged object, or undefined if both inputs are undefined
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(base?: T, override?: T): T | undefined;
+/**
+ * Load plugin configuration from user and project config files, merging them appropriately.
+ *
+ * Configuration is loaded from two locations:
+ * 1. User config: $OPENCODE_CONFIG_DIR/agent-forge.jsonc or .json,
+ *    or ~/.config/opencode/agent-forge.jsonc or .json (or $XDG_CONFIG_HOME)
+ * 2. Project config: <directory>/.opencode/agent-forge.jsonc or .json
+ *
+ * JSONC format is preferred over JSON (allows comments and trailing commas).
+ * Project config takes precedence over user config. Nested objects (agents, tmux) are
+ * deep-merged, while top-level arrays are replaced entirely by project config.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @returns Merged plugin configuration (empty object if no configs found)
+ */
+export declare function loadPluginConfig(directory: string): PluginConfig;
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
+ *
+ * @param agentName - Name of the agent (e.g., "orchestrator", "researcher")
+ * @param preset - Optional preset name for preset-scoped prompt lookup
+ * @returns Object with prompt and/or appendPrompt if files exist
+ */
+export declare function loadAgentPrompt(agentName: string, preset?: string): {
+    prompt?: string;
+    appendPrompt?: string;
+};

package/dist/config/runtime-preset.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Module-level runtime preset state.
+ *
+ * Survives plugin re-inits triggered by client.config.update() →
+ * Instance.dispose(). The plugin function re-runs but this module-level
+ * variable persists within the same Node.js process.
+ */
+export declare function setActiveRuntimePreset(name: string | null): void;
+export declare function getActiveRuntimePreset(): string | null;
+export declare function getPreviousRuntimePreset(): string | null;
+export declare function setActiveRuntimePresetWithPrevious(name: string | null): void;
+export declare function rollbackRuntimePreset(previous: string | null): void;