@serkanalgur/opencode-nexus 0.1.0

package/dist/tui.js

@@ -0,0 +1,487 @@
+// node_modules/@opencode/plugin/dist/tui/plugin.js
+function define(plugin) {
+  return plugin;
+}
+// node_modules/solid-js/dist/server.js
+var $PROXY = Symbol("solid-proxy");
+var $TRACK = Symbol("solid-track");
+var $DEVCOMP = Symbol("solid-dev-component");
+var ERROR = Symbol("error");
+function castError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function handleError(err, owner = Owner) {
+  const fns = owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns)
+    throw error;
+  try {
+    for (const f of fns)
+      f(error);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+var Owner = null;
+function createOwner() {
+  const o = {
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    owned: null,
+    cleanups: null
+  };
+  if (Owner) {
+    if (!Owner.owned)
+      Owner.owned = [o];
+    else
+      Owner.owned.push(o);
+  }
+  return o;
+}
+function createMemo(fn, value) {
+  Owner = createOwner();
+  let v;
+  try {
+    v = fn(value);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+  return () => v;
+}
+function createContext(defaultValue) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function children(fn) {
+  const memo = createMemo(() => resolveChildren(fn()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+function resolveChildren(children) {
+  if (typeof children === "function" && !children.length)
+    return resolveChildren(children());
+  if (Array.isArray(children)) {
+    const results = [];
+    for (let i = 0;i < children.length; i++) {
+      const result = resolveChildren(children[i]);
+      if (Array.isArray(result)) {
+        if (result.length < 32768)
+          results.push.apply(results, result);
+        else
+          for (let j = 0;j < result.length; j++)
+            results.push(result[j]);
+      } else {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  return children;
+}
+function createProvider(id) {
+  return function provider(props) {
+    return createMemo(() => {
+      Owner.context = {
+        ...Owner.context,
+        [id]: props.value
+      };
+      return children(() => props.children);
+    });
+  };
+}
+var SuspenseContext = createContext();
+
+// node_modules/@opencode/plugin/dist/tui/solid.js
+var PluginContext = createContext();
+// src/config.ts
+var DEFAULT_CONFIG = {
+  models: {
+    architect: "anthropic/claude-sonnet-4-6",
+    coder: "anthropic/claude-sonnet-4-6",
+    reviewer: "openai/gpt-5-mini",
+    tester: "anthropic/claude-haiku-4-5",
+    explorer: "google/gemini-2.5-flash",
+    documenter: "anthropic/claude-haiku-4-5"
+  },
+  budget: {
+    maxTotalCost: 10,
+    maxCostPerTask: 1,
+    maxCostPerAgent: 2,
+    alertThreshold: 0.2
+  },
+  selfHealing: {
+    enabled: true,
+    maxRetries: 3,
+    contextTransfer: true
+  }
+};
+
+class NexusConfigManager {
+  projectConfig = null;
+  globalConfig = null;
+  storageConfig = null;
+  constructor() {
+    this.loadConfigs();
+  }
+  loadConfigs() {
+    this.projectConfig = null;
+    this.globalConfig = null;
+  }
+  getConfig() {
+    return {
+      models: {
+        ...DEFAULT_CONFIG.models,
+        ...this.globalConfig?.models,
+        ...this.projectConfig?.models,
+        ...this.storageConfig?.models
+      },
+      budget: {
+        ...DEFAULT_CONFIG.budget,
+        ...this.globalConfig?.budget,
+        ...this.projectConfig?.budget,
+        ...this.storageConfig?.budget
+      },
+      selfHealing: {
+        ...DEFAULT_CONFIG.selfHealing,
+        ...this.globalConfig?.selfHealing,
+        ...this.projectConfig?.selfHealing,
+        ...this.storageConfig?.selfHealing
+      }
+    };
+  }
+  getModelForRole(role) {
+    const config = this.getConfig();
+    return config.models[role] || config.models.coder || DEFAULT_CONFIG.models.coder;
+  }
+  updateStorageConfig(update) {
+    this.storageConfig = {
+      ...this.storageConfig,
+      ...update,
+      models: {
+        ...this.storageConfig?.models,
+        ...update.models
+      },
+      budget: {
+        maxTotalCost: update.budget?.maxTotalCost ?? this.storageConfig?.budget?.maxTotalCost ?? DEFAULT_CONFIG.budget.maxTotalCost,
+        maxCostPerTask: update.budget?.maxCostPerTask ?? this.storageConfig?.budget?.maxCostPerTask ?? DEFAULT_CONFIG.budget.maxCostPerTask,
+        maxCostPerAgent: update.budget?.maxCostPerAgent ?? this.storageConfig?.budget?.maxCostPerAgent ?? DEFAULT_CONFIG.budget.maxCostPerAgent,
+        alertThreshold: update.budget?.alertThreshold ?? this.storageConfig?.budget?.alertThreshold ?? DEFAULT_CONFIG.budget.alertThreshold
+      },
+      selfHealing: {
+        enabled: update.selfHealing?.enabled ?? this.storageConfig?.selfHealing?.enabled ?? DEFAULT_CONFIG.selfHealing.enabled,
+        maxRetries: update.selfHealing?.maxRetries ?? this.storageConfig?.selfHealing?.maxRetries ?? DEFAULT_CONFIG.selfHealing.maxRetries,
+        contextTransfer: update.selfHealing?.contextTransfer ?? this.storageConfig?.selfHealing?.contextTransfer ?? DEFAULT_CONFIG.selfHealing.contextTransfer
+      }
+    };
+  }
+  setModel(role, model) {
+    this.storageConfig = this.storageConfig || { ...DEFAULT_CONFIG };
+    this.storageConfig.models = this.storageConfig.models || {};
+    this.storageConfig.models[role] = model;
+  }
+  getRoles() {
+    return ["architect", "coder", "reviewer", "tester", "explorer", "documenter"];
+  }
+  getRoleDisplayName(role) {
+    const names = {
+      architect: "\uD83C\uDFD7️ Architect",
+      coder: "\uD83D\uDCBB Coder",
+      reviewer: "\uD83D\uDD0D Reviewer",
+      tester: "\uD83E\uDDEA Tester",
+      explorer: "\uD83D\uDD2C Explorer",
+      documenter: "\uD83D\uDCDD Documenter"
+    };
+    return names[role] || role;
+  }
+  exportConfig() {
+    return this.getConfig();
+  }
+  importConfig(config) {
+    this.storageConfig = { ...config };
+  }
+  resetToDefaults() {
+    this.storageConfig = null;
+  }
+  getSummary() {
+    const config = this.getConfig();
+    const lines = [
+      "\uD83D\uDCCA Nexus Configuration",
+      "═══════════════════════",
+      "",
+      "\uD83E\uDD16 Agent Models:"
+    ];
+    for (const role of this.getRoles()) {
+      const model = config.models[role] || "(not set)";
+      const displayName = this.getRoleDisplayName(role);
+      lines.push(`  ${displayName}: ${model}`);
+    }
+    lines.push("");
+    lines.push("\uD83D\uDCB0 Budget:");
+    lines.push(`  Max Total: $${config.budget.maxTotalCost}`);
+    lines.push(`  Max Per Task: $${config.budget.maxCostPerTask}`);
+    lines.push(`  Alert Threshold: ${config.budget.alertThreshold * 100}%`);
+    lines.push("");
+    lines.push("\uD83D\uDEE1️ Self-Healing:");
+    lines.push(`  Enabled: ${config.selfHealing.enabled ? "✅" : "❌"}`);
+    lines.push(`  Max Retries: ${config.selfHealing.maxRetries}`);
+    lines.push(`  Context Transfer: ${config.selfHealing.contextTransfer ? "✅" : "❌"}`);
+    return lines.join(`
+`);
+  }
+}
+
+// src/tui.tsx
+var tui_default = define({
+  id: "nexus.cli",
+  setup(context) {
+    const configManager = new NexusConfigManager;
+    const handleModelSelect = async (role) => {
+      if (!configManager.getRoles().includes(role)) {
+        context.ui.toast.show({
+          title: "Nexus",
+          message: `Unknown role: ${role}. Valid: ${configManager.getRoles().join(", ")}`,
+          variant: "error"
+        });
+        return;
+      }
+      const location = context.location ?? context.data.location.default();
+      await context.data.location.model.sync(location);
+      const availableModels = context.data.location.model.list(location) ?? [];
+      const options = availableModels.map((m) => ({
+        title: m.name || m.id,
+        value: `${m.providerID}/${m.id}`,
+        description: m.providerID
+      }));
+      options.push({
+        title: "Use default",
+        value: "",
+        description: "Reset to default model"
+      });
+      const current = configManager.getModelForRole(role);
+      const selected = await context.ui.dialog.select({
+        title: `${configManager.getRoleDisplayName(role)} Model`,
+        current: current || "",
+        options
+      });
+      if (selected !== null && selected !== undefined) {
+        configManager.setModel(role, selected);
+        context.ui.toast.show({
+          title: "Nexus",
+          message: `${role} → ${selected || "default"}`,
+          variant: "success"
+        });
+      }
+    };
+    const handleConfigDialog = async () => {
+      const config = configManager.getConfig();
+      const budgetStr = await context.ui.dialog.prompt({
+        title: "Max Total Budget ($)",
+        placeholder: String(config.budget.maxTotalCost)
+      });
+      if (budgetStr !== null && budgetStr !== undefined) {
+        const budget = parseFloat(budgetStr);
+        if (!isNaN(budget) && budget > 0) {
+          configManager.updateStorageConfig({
+            budget: { ...config.budget, maxTotalCost: budget }
+          });
+          context.ui.toast.show({
+            title: "Nexus",
+            message: `Budget updated: $${budget}`,
+            variant: "success"
+          });
+        }
+      }
+    };
+    const handleFullConfig = async () => {
+      for (const role of configManager.getRoles()) {
+        await handleModelSelect(role);
+      }
+      await handleConfigDialog();
+      context.ui.toast.show({
+        title: "Nexus",
+        message: "Configuration complete!",
+        variant: "success"
+      });
+    };
+    context.keymap.layer(() => ({
+      mode: "global",
+      priority: 10,
+      commands: [
+        {
+          id: "nexus",
+          title: "Nexus Configuration",
+          group: "Nexus",
+          bind: "ctrl+n",
+          palette: true,
+          slash: { name: "nexus", aliases: [], arguments: true },
+          enabled: () => true,
+          suggested: true,
+          run: async (input) => {
+            if (input) {
+              const parts = input.split(" ");
+              const cmd = parts[0];
+              switch (cmd) {
+                case "config":
+                case "c":
+                  await handleFullConfig();
+                  break;
+                case "status":
+                case "s":
+                  context.ui.toast.show({
+                    title: "Nexus Status",
+                    message: configManager.getSummary(),
+                    variant: "info",
+                    duration: 8000
+                  });
+                  break;
+                case "model":
+                case "m":
+                  if (parts[1]) {
+                    await handleModelSelect(parts[1]);
+                  } else {
+                    const role = await context.ui.dialog.select({
+                      title: "Select Agent Role",
+                      options: configManager.getRoles().map((r) => ({
+                        title: configManager.getRoleDisplayName(r),
+                        value: r,
+                        description: `Current: ${configManager.getModelForRole(r)}`
+                      }))
+                    });
+                    if (role) {
+                      await handleModelSelect(role);
+                    }
+                  }
+                  break;
+                case "reset":
+                  const confirmed = await context.ui.dialog.confirm({
+                    title: "Reset Configuration",
+                    message: "Reset all Nexus settings to defaults?",
+                    label: { confirm: "Reset", cancel: "Cancel" }
+                  });
+                  if (confirmed) {
+                    configManager.resetToDefaults();
+                    context.ui.toast.show({
+                      title: "Nexus",
+                      message: "Configuration reset to defaults",
+                      variant: "success"
+                    });
+                  }
+                  break;
+                default:
+                  context.ui.toast.show({
+                    title: "Nexus",
+                    message: "Commands: config, status, model <role>, reset",
+                    variant: "info"
+                  });
+              }
+            } else {
+              await handleFullConfig();
+            }
+          }
+        },
+        {
+          id: "nexus.config",
+          title: "Nexus Configuration",
+          group: "Nexus",
+          palette: true,
+          slash: { name: "nexus-config", aliases: ["nc"], arguments: true },
+          enabled: () => true,
+          suggested: true,
+          run: async () => {
+            await handleFullConfig();
+          }
+        },
+        {
+          id: "nexus.model",
+          title: "Select Agent Model",
+          group: "Nexus",
+          palette: true,
+          slash: { name: "nexus-model", aliases: ["nm"], arguments: true },
+          enabled: () => true,
+          suggested: true,
+          run: async (input) => {
+            if (input) {
+              await handleModelSelect(input);
+            } else {
+              const role = await context.ui.dialog.select({
+                title: "Select Agent Role",
+                options: configManager.getRoles().map((r) => ({
+                  title: configManager.getRoleDisplayName(r),
+                  value: r,
+                  description: `Current: ${configManager.getModelForRole(r)}`
+                }))
+              });
+              if (role) {
+                await handleModelSelect(role);
+              }
+            }
+          }
+        },
+        {
+          id: "nexus.status",
+          title: "Nexus Status",
+          group: "Nexus",
+          palette: true,
+          slash: { name: "nexus-status", aliases: ["ns"], arguments: true },
+          enabled: () => true,
+          suggested: true,
+          run: async () => {
+            context.ui.toast.show({
+              title: "Nexus Status",
+              message: configManager.getSummary(),
+              variant: "info",
+              duration: 8000
+            });
+          }
+        },
+        {
+          id: "nexus.reset",
+          title: "Reset Nexus Config",
+          group: "Nexus",
+          palette: true,
+          slash: { name: "nexus-reset", aliases: [], arguments: true },
+          enabled: () => true,
+          run: async () => {
+            const confirmed = await context.ui.dialog.confirm({
+              title: "Reset Configuration",
+              message: "Reset all Nexus settings to defaults?",
+              label: { confirm: "Reset", cancel: "Cancel" }
+            });
+            if (confirmed) {
+              configManager.resetToDefaults();
+              context.ui.toast.show({
+                title: "Nexus",
+                message: "Configuration reset to defaults",
+                variant: "success"
+              });
+            }
+          }
+        }
+      ],
+      bindings: ["nexus"]
+    }));
+    context.ui.toast.show({
+      title: "⚡ Nexus Loaded",
+      message: "Type /nexus or Ctrl+N to configure",
+      variant: "info",
+      duration: 3000
+    });
+    return () => {};
+  }
+});
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@serkanalgur/opencode-nexus",
+  "version": "0.1.0",
+  "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "multi-agent",
+    "orchestration",
+    "ai",
+    "coding-agent",
+    "parallel-execution",
+    "cost-optimization"
+  ],
+  "homepage": "https://github.com/serkanalgur/opencode-nexus#readme",
+  "bugs": {
+    "url": "https://github.com/serkanalgur/opencode-nexus/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/serkanalgur/opencode-nexus.git"
+  },
+  "license": "MIT",
+  "author": "Serkan Algur",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun run build:server && bun run build:tui",
+    "build:server": "bun build ./src/index.ts --outdir ./dist --target node",
+    "build:tui": "bun build ./src/tui.tsx --outdir ./dist --target node",
+    "dev": "bun run --watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "lint": "biome check src/",
+    "format": "biome format --write src/",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@opencode/plugin": "latest"
+  },
+  "devDependencies": {
+    "@opentui/core": "^0.5.8",
+    "@opentui/solid": "^0.5.8",
+    "@types/bun": "latest",
+    "biome": "latest",
+    "bun-types": "^1.4.2",
+    "solid-js": "^1.9.0",
+    "typescript": "^5.5.0"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.8",
+    "@opentui/solid": ">=0.5.8",
+    "solid-js": ">=1.9.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}