@litfamily/litopencode 1.0.0

package/dist/agents/registry.d.ts

@@ -0,0 +1,65 @@
+import { type LitOpenCodeConfig, type LitOpenCodeAgentModelConfig } from "../config.ts";
+import type { AgentConfigTarget, LitOpenCodeAgent, OpenCodeAgentConfig } from "./types.ts";
+export declare const litOpenCodeAgents: readonly ({
+    id: string;
+    name: string;
+    tier: "default";
+    defaultRole: true;
+    recommended: true;
+    mode: "primary";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "write" | "edit" | "bash" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "role";
+    defaultRole: false;
+    recommended: true;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "write" | "edit" | "bash" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "role";
+    defaultRole: false;
+    recommended: true;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "webfetch" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "specialist";
+    defaultRole: false;
+    recommended: false;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "webfetch" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "specialist";
+    defaultRole: false;
+    recommended: false;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "write" | "edit" | "bash" | "grep")[];
+    color: string;
+    maxSteps: number;
+})[];
+export declare function toOpenCodeAgentConfig(agent: LitOpenCodeAgent, override?: LitOpenCodeAgentModelConfig): OpenCodeAgentConfig;
+export declare function registerLitOpenCodeAgents(config: AgentConfigTarget, litConfig?: LitOpenCodeConfig): void;

package/dist/agents/registry.js

@@ -0,0 +1,319 @@
+import { litOpenCodeDefaultAgents } from "./defaults.js";
+import { litOpenCodeSpecialistAgents } from "./specialists.js";
+import { withReaderFacingCommunicationContract } from "../reader-facing-output.js";
+import { defaultGlobalConfigFile, configSectionWasAuthored, effectiveAgentConfig } from "../config.js";
+import { assertSafeEffectiveAgentRoutes } from "../model-route-policy.js";
+export const litOpenCodeAgents = Object.freeze([
+    ...litOpenCodeDefaultAgents,
+    ...litOpenCodeSpecialistAgents
+]);
+const hostLeadRoute = Object.freeze({ model: "openai/gpt-6-astra", variant: "xhigh", reasoningEffort: "xhigh" });
+const specialLeadAgentIds = Object.freeze(["momus", "litwork-reviewer"]);
+const astraEfforts = new Set(["low", "medium", "high", "xhigh", "max"]);
+const astraModelMetadata = Object.freeze({
+    name: "GPT-6 Astra",
+    reasoning: true,
+    temperature: false,
+    tool_call: true
+});
+function toolsToConfig(tools) {
+    const enabledTools = {};
+    for (const tool of tools) {
+        enabledTools[tool] = true;
+    }
+    return enabledTools;
+}
+function toolsToPermission(tools) {
+    const permission = {};
+    if (tools.includes("edit") || tools.includes("write"))
+        permission.edit = "allow";
+    if (tools.includes("bash"))
+        permission.bash = "allow";
+    if (tools.includes("webfetch"))
+        permission.webfetch = "allow";
+    return Object.keys(permission).length > 0 ? permission : undefined;
+}
+const openCodePermissionKeys = Object.freeze([
+    "read",
+    "edit",
+    "glob",
+    "grep",
+    "list",
+    "bash",
+    "task",
+    "external_directory",
+    "todowrite",
+    "question",
+    "webfetch",
+    "websearch",
+    "lsp",
+    "doom_loop",
+    "skill"
+]);
+// Never invent a global `task` rule for an unconfigured user. If the user did
+// set a global string/object policy, preserve it exactly; the lineage-aware
+// runtime guard remains the authoritative child-session recursion boundary.
+const globalPermissionExpansionKeys = Object.freeze(openCodePermissionKeys.filter((key) => key !== "task"));
+function expandGlobalPermission(value) {
+    return {
+        ...Object.fromEntries(globalPermissionExpansionKeys.map((key) => [key, value])),
+        task: value
+    };
+}
+function isPermissionObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function taskPermission(value) {
+    const candidate = typeof value === "string" ? value : isPermissionObject(value) ? value.task : undefined;
+    return candidate === "allow" || candidate === "ask" || candidate === "deny" ? candidate : undefined;
+}
+function applyYoloPermissionMode(config) {
+    const existing = config.permission;
+    const basePermission = typeof existing === "string"
+        ? expandGlobalPermission(existing)
+        : isPermissionObject(existing)
+            ? existing
+            : {};
+    config.permission = {
+        ...basePermission,
+        bash: "allow",
+        edit: "allow",
+        webfetch: "allow",
+        external_directory: "allow"
+    };
+}
+function applyBalancedPermissionMode(config) {
+    const existing = config.permission;
+    const basePermission = typeof existing === "string"
+        ? expandGlobalPermission(existing)
+        : isPermissionObject(existing)
+            ? existing
+            : {};
+    const existingBash = isPermissionObject(basePermission.bash) ? basePermission.bash : undefined;
+    const dangerousAction = (pattern) => existingBash?.[pattern] === "deny" || existingBash?.["*"] === "deny" ? "deny" : "ask";
+    config.permission = {
+        ...basePermission,
+        bash: {
+            "*": "allow",
+            ...(existingBash ?? {}),
+            "rm -rf": dangerousAction("rm -rf"),
+            "rm -rf *": dangerousAction("rm -rf *"),
+            "rm -fr": dangerousAction("rm -fr"),
+            "rm -fr *": dangerousAction("rm -fr *"),
+            "sudo *": dangerousAction("sudo *"),
+            "chmod -R *": dangerousAction("chmod -R *"),
+            "chown -R *": dangerousAction("chown -R *"),
+            "dd *": dangerousAction("dd *"),
+            "mkfs *": dangerousAction("mkfs *")
+        },
+        edit: "allow",
+        webfetch: "allow"
+    };
+}
+function modePermission(agent) {
+    if (agent.id === "lit-plan")
+        return { edit: "deny", bash: "deny", task: "deny" };
+    if (agent.mode !== "primary")
+        return { task: "deny" };
+    return undefined;
+}
+function mergeTools(agent, override) {
+    const tools = { ...toolsToConfig(agent.tools), ...(override ?? {}) };
+    if (agent.id === "lit-plan") {
+        tools.write = false;
+        tools.edit = false;
+        tools.bash = false;
+        tools.task = false;
+    }
+    if (agent.mode !== "primary") {
+        tools.task = false;
+    }
+    return tools;
+}
+function mergePermission(agent, override) {
+    return { ...(toolsToPermission(agent.tools) ?? {}), ...(override ?? {}), ...(modePermission(agent) ?? {}) };
+}
+function openCodeModel(override) {
+    if (override.model === undefined)
+        return undefined;
+    if (override.provider === undefined || override.model.includes("/"))
+        return override.model;
+    return override.provider + "/" + override.model;
+}
+function hasAuthoredRouteFields(value) {
+    return value !== undefined && ["provider", "model", "variant", "reasoningEffort"].some((field) => Object.prototype.hasOwnProperty.call(value, field));
+}
+function routeFields(value) {
+    return {
+        ...(value.provider === undefined ? {} : { provider: value.provider }),
+        ...(value.model === undefined ? {} : { model: value.model }),
+        ...(value.variant === undefined ? {} : { variant: value.variant }),
+        ...(value.reasoningEffort === undefined ? {} : { reasoningEffort: value.reasoningEffort })
+    };
+}
+function leadCategoryRoute(config) {
+    const planning = config.categories.planning;
+    const review = config.categories.review;
+    if (planning === undefined || review === undefined)
+        return undefined;
+    const planningFields = routeFields(planning);
+    const reviewFields = routeFields(review);
+    const leadCategoriesAuthored = configSectionWasAuthored(config, "categories", "planning") ||
+        configSectionWasAuthored(config, "categories", "review");
+    if (!leadCategoriesAuthored && configSectionWasAuthored(config, "categories", "execution")) {
+        const execution = config.categories.execution;
+        if (execution !== undefined) {
+            const executionFields = routeFields(execution);
+            if (executionFields.model !== undefined || executionFields.provider !== undefined)
+                return executionFields;
+        }
+    }
+    if (JSON.stringify(planningFields) === JSON.stringify(reviewFields)) {
+        if (planningFields.model === undefined && planningFields.provider === undefined)
+            return undefined;
+        return planningFields;
+    }
+    if (leadCategoriesAuthored) {
+        if (configSectionWasAuthored(config, "categories", "planning") && !configSectionWasAuthored(config, "categories", "review")) {
+            return planningFields;
+        }
+        if (configSectionWasAuthored(config, "categories", "review") && !configSectionWasAuthored(config, "categories", "planning")) {
+            return reviewFields;
+        }
+        return undefined;
+    }
+    return undefined;
+}
+function routeLeadAgent(config, authoredOverride) {
+    // A user-owned lit-loop route is authoritative, even when it happens to
+    // equal the old Luna/max default. Only a homogeneous lead category route
+    // supplies the fresh/default lead when no direct route was authored.
+    if (hasAuthoredRouteFields(config.agents["lit-loop"]))
+        return authoredOverride;
+    const lead = leadCategoryRoute(config);
+    return lead === undefined ? authoredOverride : { ...authoredOverride, ...lead };
+}
+function applySpecialLeadRoute(agentTarget, agentId) {
+    const existing = agentTarget[agentId];
+    if (existing === undefined)
+        return;
+    if (["model", "variant", "reasoningEffort"].some((field) => Object.prototype.hasOwnProperty.call(existing, field)))
+        return;
+    agentTarget[agentId] = { ...existing, ...hostLeadRoute };
+}
+function registerAstraProviderModel(config) {
+    const providers = config.provider ?? {};
+    const openai = providers.openai;
+    const models = openai?.models ?? {};
+    const existingAstra = models["gpt-6-astra"];
+    const astraModel = existingAstra === undefined
+        ? { ...astraModelMetadata }
+        : {
+            ...existingAstra,
+            ...(existingAstra.name === undefined ? { name: astraModelMetadata.name } : {}),
+            ...(existingAstra.reasoning === undefined ? { reasoning: astraModelMetadata.reasoning } : {}),
+            ...(existingAstra.temperature === undefined ? { temperature: astraModelMetadata.temperature } : {}),
+            ...(existingAstra.tool_call === undefined ? { tool_call: astraModelMetadata.tool_call } : {})
+        };
+    if (existingAstra !== undefined && JSON.stringify(existingAstra) === JSON.stringify(astraModel))
+        return;
+    config.provider = {
+        ...providers,
+        openai: {
+            ...(openai ?? {}),
+            models: {
+                ...models,
+                "gpt-6-astra": astraModel
+            }
+        }
+    };
+}
+function isAstraEffort(value) {
+    return astraEfforts.has(value);
+}
+function modelFields(override) {
+    const model = openCodeModel(override);
+    const nativeReasoningEffort = override.reasoningEffort ??
+        (model === "openai/gpt-6-astra" && override.variant !== undefined && isAstraEffort(override.variant)
+            ? override.variant
+            : undefined);
+    return {
+        ...(model !== undefined ? { model } : {}),
+        ...(override.variant !== undefined ? { variant: override.variant } : {}),
+        ...(nativeReasoningEffort !== undefined ? { reasoningEffort: nativeReasoningEffort } : {}),
+        ...(override.textVerbosity !== undefined ? { textVerbosity: override.textVerbosity } : {}),
+        ...(override.thinking !== undefined ? { thinking: override.thinking } : {}),
+        ...(override.temperature !== undefined ? { temperature: override.temperature } : {}),
+        ...(override.topP !== undefined ? { top_p: override.topP } : {}),
+        ...(override.maxTokens !== undefined ? { maxTokens: override.maxTokens } : {}),
+        ...(override.providerOptions !== undefined ? { providerOptions: override.providerOptions } : {})
+    };
+}
+export function toOpenCodeAgentConfig(agent, override = {}) {
+    const permission = mergePermission(agent, override.permission);
+    const authoredPrompt = override.promptAppend === undefined ? agent.prompt : agent.prompt + "\n\n" + override.promptAppend;
+    const prompt = withReaderFacingCommunicationContract(authoredPrompt);
+    return {
+        description: agent.summary,
+        prompt,
+        mode: agent.mode === "primary" ? "all" : "subagent",
+        tools: mergeTools(agent, override.tools),
+        color: agent.color,
+        maxSteps: agent.maxSteps,
+        ...modelFields(override),
+        ...(Object.keys(permission).length > 0 ? { permission } : {})
+    };
+}
+export function registerLitOpenCodeAgents(config, litConfig = defaultGlobalConfigFile()) {
+    const routeAgentIds = [
+        ...litOpenCodeAgents.map((agent) => agent.id),
+        ...specialLeadAgentIds.filter((agentId) => litConfig.agents[agentId] !== undefined)
+    ];
+    assertSafeEffectiveAgentRoutes(litConfig, routeAgentIds);
+    registerAstraProviderModel(config);
+    const existingBuild = config.agent?.build ?? {};
+    const existingPlan = config.agent?.plan ?? {};
+    const inheritedTaskPermission = taskPermission(config.permission);
+    // The upstream AgentConfig permission type does not know the `task` key yet,
+    // while the OpenCode host resolves it at runtime; widen at this boundary only.
+    const agentTarget = {
+        ...config.agent,
+        build: {
+            ...existingBuild,
+            mode: "subagent",
+            hidden: true,
+            tools: { ...existingBuild.tools, task: false },
+            permission: { ...existingBuild.permission, task: "deny" }
+        },
+        plan: {
+            ...existingPlan,
+            mode: "subagent",
+            hidden: true,
+            tools: { ...existingPlan.tools, task: false },
+            permission: { ...existingPlan.permission, task: "deny" }
+        }
+    };
+    config.agent = agentTarget;
+    config.default_agent = "lit-loop";
+    if (litConfig?.permissionMode === "balanced") {
+        applyBalancedPermissionMode(config);
+    }
+    if (litConfig?.permissionMode === "yolo") {
+        applyYoloPermissionMode(config);
+    }
+    const primaryTaskAllow = litConfig?.permissionMode === "yolo" || litConfig?.permissionMode === "balanced";
+    for (const agent of litOpenCodeAgents) {
+        const authoredOverride = effectiveAgentConfig(litConfig, agent.id);
+        const override = agent.id === "lit-loop" ? routeLeadAgent(litConfig, authoredOverride) : authoredOverride;
+        const agentConfig = toOpenCodeAgentConfig(agent, override);
+        const entry = primaryTaskAllow && agent.mode === "primary" && agent.id !== "lit-plan"
+            ? {
+                ...agentConfig,
+                permission: { ...agentConfig.permission, task: agentConfig.permission?.task ?? inheritedTaskPermission ?? "allow" }
+            }
+            : agentConfig;
+        agentTarget[agent.id] = entry;
+    }
+    for (const agentId of specialLeadAgentIds)
+        applySpecialLeadRoute(agentTarget, agentId);
+}

package/dist/agents/specialists.d.ts

@@ -0,0 +1,49 @@
+export declare const litOpenCodeSpecialistAgents: readonly ({
+    id: string;
+    name: string;
+    tier: "role";
+    defaultRole: false;
+    recommended: true;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "write" | "edit" | "bash" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "role";
+    defaultRole: false;
+    recommended: true;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "webfetch" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "specialist";
+    defaultRole: false;
+    recommended: false;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "webfetch" | "grep")[];
+    color: string;
+    maxSteps: number;
+} | {
+    id: string;
+    name: string;
+    tier: "specialist";
+    defaultRole: false;
+    recommended: false;
+    mode: "subagent";
+    summary: string;
+    prompt: string;
+    tools: readonly ("read" | "write" | "edit" | "bash" | "grep")[];
+    color: string;
+    maxSteps: number;
+})[];