myuru 0.1.0

package/src/lib/tiers.js

@@ -0,0 +1,76 @@
+/**
+ * Tier enforcement for MyUru.
+ * FREE: 2 sequential agents. PRO: 5 concurrent + config packs.
+ */
+
+const TIERS = {
+  FREE: {
+    name: "Free",
+    maxAgents: 2,
+    maxConcurrency: 1,
+    configPacks: false,
+    price: 0,
+  },
+  PRO: {
+    name: "Pro",
+    maxAgents: 5,
+    maxConcurrency: 5,
+    configPacks: true,
+    price: 2900,
+  },
+};
+
+class TierManager {
+  constructor(tier = "FREE") {
+    this.tier = TIERS[tier] || TIERS.FREE;
+  }
+
+  canRunAgents(count) {
+    if (count > this.tier.maxAgents) {
+      return {
+        allowed: false,
+        reason: `Tier "${this.tier.name}" allows max ${this.tier.maxAgents} agents. You requested ${count}.`,
+        upgrade: `Upgrade to Pro ($29) for up to ${TIERS.PRO.maxAgents} agents.`,
+      };
+    }
+    return { allowed: true };
+  }
+
+  canUseConcurrency() {
+    if (this.tier.maxConcurrency === 1) {
+      return {
+        allowed: false,
+        reason: "Free tier only supports sequential execution.",
+        upgrade: "Upgrade to Pro ($29) for concurrent orchestration.",
+      };
+    }
+    return { allowed: true };
+  }
+
+  enforceLimit(agentCount, concurrent = false) {
+    const check = this.canRunAgents(agentCount);
+    if (!check.allowed) throw new Error(`${check.reason}\n${check.upgrade}`);
+
+    if (concurrent) {
+      const concCheck = this.canUseConcurrency();
+      if (!concCheck.allowed) {
+        console.warn(`  ${concCheck.reason} Running sequentially.`);
+        return false;
+      }
+      return true;
+    }
+    return true;
+  }
+
+  info() {
+    return {
+      tier: this.tier.name,
+      price: this.tier.price === 0 ? "Free" : `$${(this.tier.price / 100).toFixed(2)}`,
+      maxAgents: this.tier.maxAgents,
+      concurrency: this.tier.maxConcurrency > 1 ? "concurrent" : "sequential",
+      configPacks: this.tier.configPacks,
+    };
+  }
+}
+
+module.exports = { TierManager, TIERS };

package/src/providers/claude.js

@@ -0,0 +1,49 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Claude CLI provider.
+ * Wraps `claude -p` with session persistence, model selection, etc.
+ */
+class ClaudeProvider {
+  constructor(opts = {}) {
+    this.binary = opts.binary || "claude";
+  }
+
+  buildCommand({ model, sessionId, resume, maxTurns, budgetUsd, systemPrompt, promptFile, tmpDir, tempFiles }) {
+    const args = ["-p"];
+
+    if (resume) {
+      args.push("--resume", sessionId);
+    } else {
+      args.push("--session-id", sessionId);
+    }
+
+    args.push("--model", model);
+
+    if (budgetUsd) {
+      args.push("--max-budget-usd", String(budgetUsd));
+    }
+
+    if (systemPrompt) {
+      const sysFile = path.join(tmpDir, `sysprompt-${Date.now()}.txt`);
+      fs.writeFileSync(sysFile, systemPrompt, "utf-8");
+      const sysFileWin = sysFile.replace(/\//g, "\\");
+      args.push("--system-prompt-file", `"${sysFileWin}"`);
+      tempFiles.push(sysFile);
+    }
+
+    if (maxTurns) {
+      args.push("--max-turns", String(maxTurns));
+    }
+
+    args.push("--dangerously-skip-permissions");
+
+    const promptFileWin = promptFile.replace(/\//g, "\\");
+    args.push(`< "${promptFileWin}"`);
+
+    return { cmd: this.binary, args, env: {} };
+  }
+}
+
+module.exports = ClaudeProvider;

package/src/providers/index.js

@@ -0,0 +1,17 @@
+const ClaudeProvider = require("./claude");
+const OpenAIProvider = require("./openai");
+
+const PROVIDERS = {
+  claude: ClaudeProvider,
+  openai: OpenAIProvider,
+};
+
+function createProvider(name, opts = {}) {
+  const Provider = PROVIDERS[name];
+  if (!Provider) {
+    throw new Error(`Unknown provider "${name}". Available: ${Object.keys(PROVIDERS).join(", ")}`);
+  }
+  return new Provider(opts);
+}
+
+module.exports = { createProvider, ClaudeProvider, OpenAIProvider, PROVIDERS };

package/src/providers/openai.js

@@ -0,0 +1,57 @@
+/**
+ * OpenAI provider — uses the OpenAI API via fetch.
+ * Requires OPENAI_API_KEY in environment.
+ *
+ * For v0.1.0: basic chat completions. No session persistence.
+ */
+class OpenAIProvider {
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey || process.env.OPENAI_API_KEY;
+    this.baseUrl = opts.baseUrl || "https://api.openai.com/v1";
+  }
+
+  static MODELS = {
+    "gpt-4o": "gpt-4o",
+    "gpt-4o-mini": "gpt-4o-mini",
+    "gpt-4-turbo": "gpt-4-turbo",
+    "o1": "o1",
+    "o1-mini": "o1-mini",
+  };
+
+  async invoke(prompt, { model = "gpt-4o-mini", systemPrompt = "" } = {}) {
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY not set. Run: export OPENAI_API_KEY=sk-...");
+    }
+
+    const messages = [];
+    if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
+    messages.push({ role: "user", content: prompt });
+
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: OpenAIProvider.MODELS[model] || model,
+        messages,
+        max_tokens: 4096,
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`OpenAI API error ${res.status}: ${text.slice(0, 200)}`);
+    }
+
+    const data = await res.json();
+    return data.choices[0]?.message?.content || "";
+  }
+
+  buildCommand() {
+    throw new Error("OpenAI provider uses invoke() directly, not buildCommand().");
+  }
+}
+
+module.exports = OpenAIProvider;