myuru 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wittlesus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# MyUru
+
+[![npm version](https://img.shields.io/npm/v/myuru.svg)](https://www.npmjs.com/package/myuru)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Multi-provider AI agent orchestrator. Coordinate Claude, GPT, and Gemini agents to build software in parallel.
+
+## Features
+
+- **Multi-Provider**: Claude, OpenAI, Gemini
+- **Council Mode**: Agents deliberate in a chatroom, then execute tasks together
+- **Session Persistence**: Agents maintain context across invocations
+- **Terminal Dashboard**: Real-time ANSI UI showing agent status
+- **Tier System**: Free (2 sequential agents) / Pro (5 concurrent + config packs, $29 one-time)
+
+## Installation
+
+```bash
+npm install -g myuru
+```
+
+## Quick Start
+
+Initialize a project:
+
+```bash
+myuru init
+```
+
+Run agents on a task:
+
+```bash
+myuru run --task "Build a login page with JWT auth"
+```
+
+Output:
+```
+[Agent Architect] Designing authentication system...
+[Agent Frontend] Building React login form...
+[Agent Security] Implementing JWT validation...
+
+Tasks completed: 3/3 | Status: SUCCESS
+```
+
+Start a council discussion:
+
+```bash
+myuru council \
+  --topic "Design auth system" \
+  --agents "Architect,Security,Frontend"
+```
+
+Check task progress:
+
+```bash
+myuru status
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `myuru init` | Initialize project with config |
+| `myuru run --task "..."` | Run agents on a task |
+| `myuru council --topic "..." --agents "..."` | Start council deliberation |
+| `myuru status` | View task progress |
+
+## Configuration
+
+Set environment variables:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GOOGLE_API_KEY="..."
+```
+
+Create `.myuru.json`:
+
+```json
+{
+  "tier": "free",
+  "providers": ["claude", "openai"],
+  "maxConcurrent": 2
+}
+```
+
+## Pricing
+
+**Free**: 2 sequential agents, basic reporting
+**Pro**: 5 concurrent agents, config packs, priority support — $29 one-time
+
+## Requirements
+
+- Node.js >= 18
+- Claude CLI (for Claude provider)
+- API keys for your chosen providers
+
+## License
+
+MIT - See LICENSE file
+
+---
+
+Built by Wittlesus | [GitHub](https://github.com/Wittlesus/myuru)

package/bin/myuru.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const path = require('path');
+const pkg = require('../package.json');
+
+const program = new Command();
+
+program
+  .name('myuru')
+  .description('Multi-provider AI agent orchestrator')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Initialize a MyUru project in the current directory')
+  .option('--template <name>', 'Config pack template to use', 'default')
+  .action(async (opts) => {
+    const { init } = require('../src/commands/init');
+    await init(opts);
+  });
+
+program
+  .command('run')
+  .description('Run the orchestrator on the current project')
+  .option('-t, --task <description>', 'Single task to execute')
+  .option('-f, --file <path>', 'Task file (myuru.config.mjs or JSON)')
+  .option('--provider <name>', 'Single provider: claude, openai, gemini', 'claude')
+  .option('--model <name>', 'Model override')
+  .option('--agents <n>', 'Number of builder agents', '2')
+  .option('--pro', 'Enable Pro tier (concurrent execution, more agents)')
+  .option('--budget <usd>', 'Max budget in USD')
+  .option('--dry-run', 'Show what would run without executing')
+  .action(async (opts) => {
+    const { run } = require('../src/commands/run');
+    await run(opts);
+  });
+
+program
+  .command('status')
+  .description('Show task progress and agent status')
+  .action(async () => {
+    const { status } = require('../src/commands/status');
+    await status();
+  });
+
+program
+  .command('council')
+  .description('Start a council session — agents deliberate, then execute')
+  .option('--topic <text>', 'Topic for council discussion')
+  .option('--agents <names>', 'Comma-separated agent roles', 'Architect,Reviewer,Tester')
+  .option('--rounds <n>', 'Max deliberation rounds', '3')
+  .option('--execute', 'Auto-execute tasks after deliberation')
+  .action(async (opts) => {
+    const { council } = require('../src/commands/council');
+    await council(opts);
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "myuru",
+  "version": "0.1.0",
+  "description": "Multi-provider AI agent orchestrator. Coordinate Claude, GPT, and Gemini agents to build software in parallel.",
+  "main": "src/index.js",
+  "bin": {
+    "myuru": "./bin/myuru.js"
+  },
+  "scripts": {
+    "test": "node --test src/**/*.test.js",
+    "start": "node bin/myuru.js"
+  },
+  "keywords": [
+    "ai",
+    "orchestrator",
+    "multi-agent",
+    "multi-provider",
+    "claude",
+    "openai",
+    "gemini",
+    "coding-agent",
+    "automation",
+    "cli"
+  ],
+  "author": "Wittlesus",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Wittlesus/myuru"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  }
+}

package/src/commands/council.js

@@ -0,0 +1,168 @@
+const { spawn } = require("child_process");
+const path = require("path");
+const http = require("http");
+const CouncilServer = require("../lib/council-server");
+const { TierManager } = require("../lib/tiers");
+
+async function council(opts) {
+  const topic = opts.topic;
+  if (!topic) {
+    console.error("No topic specified. Use --topic \"...\"");
+    process.exit(1);
+  }
+
+  const agentNames = (opts.agents || "Architect,Reviewer,Tester").split(",").map(a => a.trim());
+  const maxRounds = parseInt(opts.rounds) || 3;
+  const shouldExecute = opts.execute || false;
+
+  // Tier check
+  const tier = new TierManager("FREE");
+  try {
+    tier.enforceLimit(agentNames.length);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+
+  console.log("MyUru Council");
+  console.log("─".repeat(50));
+  console.log(`Topic: ${topic}`);
+  console.log(`Agents: ${agentNames.join(", ")}`);
+  console.log(`Rounds: ${maxRounds}`);
+  console.log("");
+
+  // Start council server
+  const server = new CouncilServer();
+  const port = await server.start();
+  console.log(`Council server on port ${port}`);
+
+  // Configure session
+  server.config.agents = agentNames;
+  server.config.maxRounds = maxRounds;
+
+  const base = `http://localhost:${port}`;
+
+  // Default role prompts
+  const rolePrompts = {
+    Architect: "Focus on technical feasibility. Challenge complexity. Push for simplicity.",
+    Reviewer: "Focus on code quality and edge cases. Challenge assumptions.",
+    Tester: "Focus on testability. What could break? Push for test coverage.",
+    Revenue: "Focus on monetization. Challenge anything without revenue path.",
+    Growth: "Focus on user acquisition. How do users find this?",
+    Security: "Focus on security implications. What attack surfaces exist?",
+  };
+
+  // Spawn agents for deliberation
+  console.log("\n--- DELIBERATION ---\n");
+
+  const spawnAgent = (name) => {
+    const prompt = [
+      `You are "${name}" in a council discussion.`,
+      `TOPIC: ${topic}`,
+      `YOUR ROLE: ${name}. Stay in character. Be concise.`,
+      "CHATROOM PROTOCOL:",
+      `- Send message: curl -s -X POST ${base}/chat -H "Content-Type: application/json" -d '{"agent":"${name}","message":"YOUR MSG"}'`,
+      `- Read messages: curl -s "${base}/chat?since=-1"`,
+      `- Keep messages under 300 chars.`,
+      `- You have ${maxRounds} rounds. Each round: read, think, respond.`,
+      "- Reference other agents by name. Agree, disagree, challenge.",
+      "EFFICIENCY RULES:",
+      "- One message per round. No essays.",
+      "- Agree in 1 sentence + 1 new insight. Disagree in 2-3 sentences max.",
+      rolePrompts[name] || `You are ${name}. Contribute your perspective.`,
+      `START: Post opening position (2 sentences), then loop for ${maxRounds} rounds.`,
+    ].join("\n");
+
+    console.log(`  Spawning ${name}...`);
+
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+
+    // Intentional spawn — core product functionality
+    const child = spawn("claude", ["--model", "haiku", "-p"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      shell: true,
+    });
+
+    child.stdin.write(prompt);
+    child.stdin.end();
+
+    let output = "";
+    child.stdout?.on("data", d => output += d.toString());
+    child.stderr?.on("data", d => output += d.toString());
+
+    return new Promise(resolve => {
+      child.on("close", code => {
+        console.log(`  ${name} finished (exit ${code})`);
+        resolve({ name, code, output: output.substring(0, 500) });
+      });
+      child.on("error", () => {
+        resolve({ name, code: -1, output: "spawn error" });
+      });
+    });
+  };
+
+  const results = await Promise.all(agentNames.map(spawnAgent));
+
+  // Get transcript
+  const transcript = server.messages
+    .map(m => `[R${m.round}] **${m.agent}**: ${m.message}`)
+    .join("\n\n");
+
+  console.log(`\nDeliberation complete: ${server.messages.length} messages across ${server.currentRound} rounds.\n`);
+
+  if (transcript) {
+    console.log("--- TRANSCRIPT ---\n");
+    console.log(transcript.substring(0, 3000));
+    console.log("");
+  }
+
+  // Task extraction
+  if (shouldExecute && server.messages.length > 0) {
+    console.log("--- TASK EXTRACTION ---\n");
+
+    const extractPrompt = [
+      "Read this council debate and extract 3-6 concrete tasks.",
+      `Output a JSON array: [{id, title, description, assignee, priority}].`,
+      `Assignee must be one of: ${agentNames.join(", ")}.`,
+      "Only output the JSON array.",
+      "",
+      "TRANSCRIPT:",
+      transcript.substring(0, 4000),
+    ].join("\n");
+
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+
+    const taskOutput = await new Promise(resolve => {
+      const child = spawn("claude", ["--model", "haiku", "-p"], {
+        stdio: ["pipe", "pipe", "pipe"], env, shell: true,
+      });
+      child.stdin.write(extractPrompt);
+      child.stdin.end();
+      let out = "";
+      child.stdout?.on("data", d => out += d.toString());
+      child.stderr?.on("data", d => out += d.toString());
+      child.on("close", () => resolve(out));
+    });
+
+    let tasks = [];
+    try {
+      const jsonMatch = taskOutput.match(/\[[\s\S]*\]/);
+      tasks = jsonMatch ? JSON.parse(jsonMatch[0]) : [];
+    } catch {
+      console.log("Failed to parse tasks from output.");
+    }
+
+    if (tasks.length > 0) {
+      console.log(`Extracted ${tasks.length} tasks:`);
+      tasks.forEach(t => console.log(`  [${t.assignee}] ${t.title}`));
+    }
+  }
+
+  await server.stop();
+  console.log("\nCouncil session complete.");
+}
+
+module.exports = { council };

package/src/commands/init.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+
+async function init(opts) {
+  const cwd = process.cwd();
+  const configFile = path.join(cwd, "myuru.config.mjs");
+  const stateDir = path.join(cwd, ".myuru");
+
+  if (fs.existsSync(configFile)) {
+    console.log("myuru.config.mjs already exists in this directory.");
+    return;
+  }
+
+  // Create .myuru state directory
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, ".gitignore"), "*\n");
+
+  // Write default config
+  const template = opts.template || "default";
+  const config = getTemplate(template);
+  fs.writeFileSync(configFile, config);
+
+  console.log("Initialized MyUru project:");
+  console.log(`  ${configFile}`);
+  console.log(`  ${stateDir}/`);
+  console.log("");
+  console.log("Next: myuru run --task \"Build a login page\"");
+}
+
+function getTemplate(name) {
+  const templates = {
+    default: `// myuru.config.mjs — MyUru orchestrator configuration
+export default {
+  // Provider: "claude", "openai", or "gemini" (coming soon)
+  provider: "claude",
+
+  // Model to use for execution
+  model: "sonnet",
+
+  // Number of builder agents
+  agents: 2,
+
+  // Agent roles and system prompts
+  roles: {
+    Builder: "You are a software engineer. Write clean, working code.",
+    Reviewer: "You review code for bugs, security issues, and quality.",
+  },
+
+  // Budget limit per run (USD)
+  budget: 5,
+
+  // Max turns per agent invocation
+  maxTurns: 10,
+};
+`,
+    minimal: `export default {
+  provider: "claude",
+  model: "sonnet",
+  agents: 1,
+};
+`,
+  };
+
+  return templates[name] || templates.default;
+}
+
+module.exports = { init };

package/src/commands/run.js

@@ -0,0 +1,179 @@
+const fs = require("fs");
+const path = require("path");
+const { createProvider } = require("../providers");
+const AgentRunner = require("../lib/agent-runner");
+const TaskDB = require("../lib/task-db");
+const Dashboard = require("../lib/dashboard");
+const { TierManager } = require("../lib/tiers");
+
+async function run(opts) {
+  const cwd = process.cwd();
+  const stateDir = path.join(cwd, ".myuru");
+  fs.mkdirSync(stateDir, { recursive: true });
+
+  // Load config
+  let config = {};
+  const configFile = path.join(cwd, "myuru.config.mjs");
+  if (fs.existsSync(configFile)) {
+    try {
+      config = (await import(`file://${configFile.replace(/\\/g, "/")}`)).default;
+    } catch {}
+  }
+
+  // CLI overrides
+  const providerName = opts.provider || config.provider || "claude";
+  const model = opts.model || config.model || "sonnet";
+  const agentCount = parseInt(opts.agents) || config.agents || 2;
+  const budget = opts.budget || config.budget || "5";
+  const maxTurns = config.maxTurns || 10;
+  const isPro = opts.pro || false;
+
+  // Tier enforcement
+  const tier = new TierManager(isPro ? "PRO" : "FREE");
+  const tierInfo = tier.info();
+
+  console.log(`MyUru v0.1.0 | ${tierInfo.tier} tier | ${providerName}/${model}`);
+  console.log(`Agents: ${agentCount} | Execution: ${tierInfo.concurrency}`);
+  console.log("─".repeat(50));
+
+  try {
+    tier.enforceLimit(agentCount, isPro);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+
+  // Resolve task
+  let task = opts.task;
+  if (!task && opts.file) {
+    task = fs.readFileSync(opts.file, "utf-8");
+  }
+  if (!task) {
+    console.error("No task specified. Use --task \"...\" or --file <path>");
+    process.exit(1);
+  }
+
+  if (opts.dryRun) {
+    console.log("\nDry run — would execute:");
+    console.log(`  Task: ${task}`);
+    console.log(`  Provider: ${providerName}/${model}`);
+    console.log(`  Agents: ${agentCount}`);
+    console.log(`  Budget: $${budget}`);
+    return;
+  }
+
+  // Create provider and DB
+  const provider = createProvider(providerName);
+  const db = new TaskDB(stateDir);
+
+  // Create task in DB
+  const taskId = `task-${Date.now()}`;
+  db.createTask({
+    id: taskId,
+    title: task.substring(0, 100),
+    description: task,
+    priority: 1,
+    createdBy: "user",
+  });
+
+  // Create agents
+  const agents = [];
+  const roles = config.roles || { Builder: "You are a software engineer. Write clean, working code." };
+  const roleNames = Object.keys(roles).slice(0, agentCount);
+
+  for (let i = 0; i < agentCount; i++) {
+    const roleName = roleNames[i % roleNames.length];
+    agents.push(new AgentRunner({
+      id: `${roleName}-${i}`,
+      model,
+      provider,
+      systemPrompt: roles[roleName] || `You are ${roleName}. Complete the task efficiently.`,
+      maxTurns,
+      budgetUsd: budget,
+      cwd,
+      stateless: true,
+    }));
+  }
+
+  // Dashboard
+  const dashboard = new Dashboard();
+  const startTime = Date.now();
+
+  dashboard.start(() => {
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+    const running = agents.filter(a => a.busy).length;
+    const done = agents.filter(a => a.invocationCount > 0 && !a.busy).length;
+    return [
+      `\x1b[36mMyUru\x1b[0m | ${providerName}/${model} | ${tierInfo.tier}`,
+      `Task: ${task.substring(0, 60)}`,
+      `Agents: ${running} running, ${done} done | ${elapsed}s elapsed`,
+      "─".repeat(dashboard.cols),
+    ];
+  });
+
+  // Execute
+  console.log(`\nExecuting with ${agentCount} agent(s)...\n`);
+
+  const runAgent = async (agent, idx) => {
+    const prompt = [
+      `PROJECT DIRECTORY: ${cwd}`,
+      `TASK: ${task}`,
+      "",
+      `You are agent ${idx + 1} of ${agentCount}.`,
+      agentCount > 1 ? `Focus on your part. Agent roles: ${roleNames.join(", ")}.` : "",
+      "",
+      "Complete the task. Be efficient. Ship working code.",
+    ].filter(Boolean).join("\n");
+
+    db.assignTask(taskId, agent.id);
+    db.startTask(taskId, agent.id);
+    dashboard.log(`[${agent.id}] Starting...`);
+
+    try {
+      const output = await agent.invoke(prompt, taskId);
+      dashboard.log(`[${agent.id}] Done (${output.length} chars)`);
+      return { agent: agent.id, success: true, output };
+    } catch (err) {
+      dashboard.log(`[${agent.id}] Failed: ${err.message}`);
+      return { agent: agent.id, success: false, error: err.message };
+    }
+  };
+
+  let results;
+  if (isPro && agentCount > 1) {
+    // Concurrent execution (PRO)
+    results = await Promise.all(agents.map((a, i) => runAgent(a, i)));
+  } else {
+    // Sequential execution (FREE)
+    results = [];
+    for (let i = 0; i < agents.length; i++) {
+      results.push(await runAgent(agents[i], i));
+    }
+  }
+
+  dashboard.stop();
+
+  // Summary
+  const successes = results.filter(r => r.success).length;
+  const failures = results.filter(r => !r.success).length;
+
+  if (successes > 0) {
+    db.completeTask(taskId, "orchestrator", `${successes} agents completed`);
+  } else {
+    db.failTask(taskId, "orchestrator", `All ${failures} agents failed`);
+  }
+
+  console.log("\nResults:");
+  console.log("─".repeat(50));
+  for (const r of results) {
+    const icon = r.success ? "OK" : "XX";
+    console.log(`  [${icon}] ${r.agent}`);
+    if (r.output) console.log(`       ${r.output.substring(0, 200)}`);
+    if (r.error) console.log(`       Error: ${r.error}`);
+  }
+  console.log(`\n${successes} succeeded, ${failures} failed.`);
+
+  db.close();
+}
+
+module.exports = { run };

package/src/commands/status.js

@@ -0,0 +1,49 @@
+const fs = require("fs");
+const path = require("path");
+const TaskDB = require("../lib/task-db");
+
+async function status() {
+  const stateDir = path.join(process.cwd(), ".myuru");
+
+  if (!fs.existsSync(stateDir)) {
+    console.log("No MyUru project found. Run: myuru init");
+    return;
+  }
+
+  const db = new TaskDB(stateDir);
+  const tasks = db.getAllTasks();
+  const stats = db.getTaskStats();
+
+  if (tasks.length === 0) {
+    console.log("No tasks yet. Run: myuru run --task \"...\"");
+    return;
+  }
+
+  console.log("MyUru Task Status");
+  console.log("─".repeat(60));
+
+  const statusIcons = {
+    pending: "  ",
+    assigned: ">>",
+    in_progress: "**",
+    done: "OK",
+    failed: "XX",
+  };
+
+  for (const task of tasks) {
+    const icon = statusIcons[task.status] || "??";
+    const agent = task.assigned_to ? ` (${task.assigned_to})` : "";
+    console.log(`  [${icon}] ${task.title}${agent}`);
+    if (task.result) {
+      console.log(`       -> ${task.result.substring(0, 80)}`);
+    }
+  }
+
+  console.log("");
+  console.log("Summary:");
+  for (const s of stats) {
+    console.log(`  ${s.status}: ${s.count}`);
+  }
+}
+
+module.exports = { status };