@a-company/paradigm 1.5.0

package/dist/cursor-cli-IHJMPRCW.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+import {
+  MODEL_PRICING
+} from "./chunk-5JGJACDU.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/core/providers/cursor-cli.ts
+import * as fs from "fs";
+import * as path from "path";
+import { spawn, execSync } from "child_process";
+import { EventEmitter } from "events";
+var CursorCliProvider = class {
+  name = "cursor-cli";
+  agentPath = null;
+  constructor() {
+  }
+  listModels() {
+    return ["opus", "sonnet", "haiku"];
+  }
+  supportsParallel() {
+    return true;
+  }
+  supportsMcp() {
+    return true;
+  }
+  getTokenCost(model) {
+    return MODEL_PRICING[model];
+  }
+  /**
+   * Check if Cursor CLI is available
+   */
+  async isAvailable() {
+    if (!this.isCursorEnvironment()) {
+      return false;
+    }
+    try {
+      const result = execSync("which agent", { encoding: "utf-8" }).trim();
+      if (result) {
+        this.agentPath = result;
+        return true;
+      }
+    } catch {
+      const paths = [
+        "/usr/local/bin/agent",
+        path.join(process.env.HOME || "", ".local/bin/agent"),
+        path.join(process.env.HOME || "", ".cursor/bin/agent"),
+        // macOS application paths
+        "/Applications/Cursor.app/Contents/Resources/app/bin/agent"
+      ];
+      for (const p of paths) {
+        if (fs.existsSync(p)) {
+          this.agentPath = p;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Detect if running in Cursor environment
+   */
+  isCursorEnvironment() {
+    return process.env.TERM_PROGRAM === "cursor" || !!process.env.CURSOR_SESSION || !!process.env.CURSOR_TRACE_ID || (process.env.VSCODE_CWD?.toLowerCase().includes("cursor") ?? false) || (process.env.VSCODE_NLS_CONFIG?.toLowerCase().includes("cursor") ?? false) || process.env.TERM_PROGRAM === "vscode" && (process.env.VSCODE_GIT_ASKPASS_NODE?.toLowerCase().includes("cursor") ?? false);
+  }
+  /**
+   * Spawn an agent by invoking Cursor CLI
+   */
+  async *spawn(agent, options) {
+    if (!this.agentPath) {
+      yield {
+        type: "error",
+        content: "Cursor agent CLI not found",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return;
+    }
+    const prompt = this.buildPrompt(agent, options);
+    yield {
+      type: "text",
+      content: `Starting ${agent.name} agent via Cursor CLI...
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const args = [
+      "-p",
+      prompt.slice(0, 8e3)
+      // Non-interactive mode with prompt
+    ];
+    if (options.model) {
+      const cursorModel = this.mapToCursorModel(options.model);
+      if (cursorModel) {
+        args.push("--model", cursorModel);
+      }
+    }
+    const messageEmitter = new EventEmitter();
+    let outputBuffer = "";
+    let totalUsage = { input: 0, output: 0, total: 0 };
+    let lastError = null;
+    let completed = false;
+    const proc = spawn(this.agentPath, args, {
+      cwd: options.workingDirectory || process.cwd(),
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.stdout?.on("data", (data) => {
+      const text = data.toString();
+      outputBuffer += text;
+      messageEmitter.emit("text", text);
+    });
+    proc.stderr?.on("data", (data) => {
+      const text = data.toString();
+      if (text.toLowerCase().includes("error")) {
+        lastError = text;
+        messageEmitter.emit("error", new Error(text));
+      } else {
+        messageEmitter.emit("progress", text);
+      }
+    });
+    proc.on("close", (code) => {
+      completed = true;
+      const outputTokens = Math.ceil(outputBuffer.length / 4);
+      const inputTokens = Math.ceil(prompt.length / 4);
+      totalUsage = {
+        input: inputTokens,
+        output: outputTokens,
+        total: inputTokens + outputTokens
+      };
+      messageEmitter.emit("done", code);
+    });
+    proc.on("error", (err) => {
+      lastError = err.message;
+      messageEmitter.emit("error", err);
+    });
+    const timeoutMs = options.timeout || 5 * 60 * 1e3;
+    const timeoutHandle = setTimeout(() => {
+      proc.kill();
+      lastError = `Cursor agent timed out after ${timeoutMs / 1e3}s`;
+      messageEmitter.emit("timeout");
+    }, timeoutMs);
+    const messageQueue = [];
+    let resolveNext = null;
+    const pushMessage = (msg) => {
+      if (resolveNext) {
+        resolveNext(msg);
+        resolveNext = null;
+      } else {
+        messageQueue.push(msg);
+      }
+    };
+    messageEmitter.on("text", (text) => {
+      pushMessage({
+        type: "text",
+        content: text,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    messageEmitter.on("progress", (_text) => {
+      pushMessage({
+        type: "text",
+        content: ".",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    messageEmitter.on("done", () => {
+      clearTimeout(timeoutHandle);
+      pushMessage({
+        type: "done",
+        content: "Agent completed",
+        usage: totalUsage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    messageEmitter.on("timeout", () => {
+      pushMessage({
+        type: "error",
+        content: lastError || "Timeout",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    messageEmitter.on("error", (err) => {
+      clearTimeout(timeoutHandle);
+      pushMessage({
+        type: "error",
+        content: err.message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    while (!completed || messageQueue.length > 0) {
+      if (messageQueue.length > 0) {
+        const msg = messageQueue.shift();
+        yield msg;
+        if (msg.type === "done" || msg.type === "error") {
+          break;
+        }
+      } else {
+        const msg = await new Promise((resolve) => {
+          resolveNext = resolve;
+          setTimeout(() => resolve(null), 100);
+        });
+        if (msg) {
+          yield msg;
+          if (msg.type === "done" || msg.type === "error") {
+            break;
+          }
+        }
+      }
+    }
+    if (lastError && !completed) {
+      yield {
+        type: "error",
+        content: lastError,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  /**
+   * Build prompt for the agent
+   */
+  buildPrompt(agent, options) {
+    const parts = [];
+    parts.push(`# ${agent.name.toUpperCase()} Agent`);
+    parts.push("");
+    parts.push("## Role");
+    parts.push(agent.role);
+    parts.push("");
+    parts.push("## Task");
+    parts.push(options.task);
+    parts.push("");
+    if (options.context.systemPrompt) {
+      parts.push("## Context");
+      parts.push(options.context.systemPrompt.slice(0, 3e3));
+      parts.push("");
+    }
+    if (options.context.symbols.length > 0) {
+      parts.push("## Symbols");
+      parts.push(options.context.symbols.join(", "));
+      parts.push("");
+    }
+    if (options.context.handoffContext) {
+      parts.push("## From Previous Agent");
+      parts.push(options.context.handoffContext);
+      parts.push("");
+    }
+    parts.push("## Instructions");
+    parts.push("Complete the task above. Be concise and focused. Keep response under 500 words.");
+    return parts.join("\n");
+  }
+  /**
+   * Map Paradigm model tiers to Cursor model names
+   */
+  mapToCursorModel(model) {
+    switch (model) {
+      case "opus":
+        return "claude-opus-4-6";
+      case "sonnet":
+        return "claude-sonnet-4-5-20250929";
+      case "haiku":
+        return "claude-haiku-4-5-20251001";
+      default:
+        return null;
+    }
+  }
+};
+export {
+  CursorCliProvider
+};

package/dist/cursorrules-KI5QWHIX.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  cursorrrulesExists,
+  generateCursorrules,
+  paradigmConfigExists,
+  writeCursorrules
+} from "./chunk-UUZ2DMG5.js";
+import "./chunk-N6PJAPDE.js";
+import {
+  getDefaultParadigmConfig,
+  parseParadigmConfig,
+  serializeParadigmConfig
+} from "./chunk-YO6DVTL7.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/cursorrules.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function cursorrrulesCommand(targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  const projectName = path.basename(rootDir);
+  const configPath = path.join(rootDir, ".paradigm");
+  const spinner = ora();
+  if (!paradigmConfigExists(rootDir)) {
+    if (options.init) {
+      spinner.start("Creating .paradigm config...");
+      const defaultConfig = getDefaultParadigmConfig(projectName);
+      fs.writeFileSync(configPath, serializeParadigmConfig(defaultConfig), "utf8");
+      spinner.succeed(chalk.green(".paradigm config created"));
+    } else {
+      console.log(chalk.red("\n\u274C No .paradigm file found."));
+      console.log(chalk.gray("\nRun with --init to create a default .paradigm config:"));
+      console.log(chalk.cyan("  paradigm cursorrules --init\n"));
+      process.exit(1);
+    }
+  }
+  let config;
+  try {
+    const content = fs.readFileSync(configPath, "utf8");
+    config = parseParadigmConfig(content);
+  } catch (err) {
+    const error = err;
+    console.log(chalk.red(`
+\u274C Failed to parse .paradigm: ${error.message}
+`));
+    process.exit(1);
+  }
+  const scanIndexExists = fs.existsSync(path.join(rootDir, ".paradigm", "scan-index.json")) || fs.existsSync(path.join(rootDir, ".paradigm-scan-index.json"));
+  const includeScan = options.withScan || scanIndexExists;
+  if (options.preview) {
+    const content = generateCursorrules(config, projectName, { withScan: includeScan });
+    console.log(chalk.blue("\n--- Preview of .cursorrules content ---\n"));
+    console.log(content);
+    console.log(chalk.blue("\n--- End preview ---\n"));
+    return;
+  }
+  let mode = "create";
+  if (options.append) {
+    mode = "append";
+  } else if (!options.force && cursorrrulesExists(rootDir)) {
+    console.log(chalk.yellow("\n\u26A0\uFE0F  .cursorrules already exists."));
+    console.log(chalk.gray("Use --force to overwrite, or --append to add Paradigm section.\n"));
+    process.exit(1);
+  }
+  spinner.start("Generating .cursorrules...");
+  const result = writeCursorrules(rootDir, config, mode, projectName, { withScan: includeScan });
+  if (result.success) {
+    spinner.succeed(chalk.green(result.message));
+    console.log(chalk.gray(`
+  Path: ${result.path}`));
+    if (includeScan) {
+      console.log(chalk.gray("  Includes: Scan protocol"));
+    }
+    console.log();
+  } else {
+    spinner.fail(chalk.red("Failed to generate .cursorrules"));
+    process.exit(1);
+  }
+}
+export {
+  cursorrrulesCommand
+};

package/dist/diff-AJJ5H6HV.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  BackgroundOrchestrator
+} from "./chunk-AD2LSCHB.js";
+import "./chunk-6QC3YGB6.js";
+import "./chunk-WS5KM7OL.js";
+import "./chunk-PBHIFAL4.js";
+import "./chunk-TAP5N3HH.js";
+import "./chunk-PMXRGPRQ.js";
+import "./chunk-5C4SGQKH.js";
+import "./chunk-PW2EXJQT.js";
+import "./chunk-IRKUEJVW.js";
+import "./chunk-5JGJACDU.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/team/diff.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+async function teamDiffCommand(orchestrationId, targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  if (!orchestrationId) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration ID required" }));
+    } else {
+      console.log(chalk.red("\nOrchestration ID required."));
+      console.log(chalk.gray("Usage: paradigm team diff <orchestration-id>\n"));
+    }
+    return;
+  }
+  const bgOrchestrator = new BackgroundOrchestrator(rootDir);
+  const orch = bgOrchestrator.getOrchestration(orchestrationId);
+  if (!orch) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration not found", id: orchestrationId }));
+    } else {
+      console.log(chalk.red(`
+Orchestration not found: ${orchestrationId}
+`));
+    }
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      id: orch.id,
+      task: orch.task,
+      status: orch.status,
+      artifacts: orch.artifacts
+    }, null, 2));
+    return;
+  }
+  console.log();
+  console.log(chalk.blue("\u2501".repeat(60)));
+  console.log(chalk.blue(`  Diff: ${orch.id}`));
+  console.log(chalk.blue("\u2501".repeat(60)));
+  console.log();
+  console.log(chalk.gray(`  Task: ${orch.task.slice(0, 50)}${orch.task.length > 50 ? "..." : ""}`));
+  console.log(chalk.gray(`  Status: ${orch.status}`));
+  console.log();
+  if (orch.artifacts.length === 0) {
+    console.log(chalk.gray("  No file changes in this orchestration."));
+    console.log();
+    return;
+  }
+  console.log(chalk.cyan("  Files Changed:"));
+  console.log();
+  const created = [];
+  const modified = [];
+  const deleted = [];
+  for (const artifact of orch.artifacts) {
+    if (artifact.action === "created") {
+      created.push(artifact.path);
+    } else if (artifact.action === "modified") {
+      modified.push(artifact.path);
+    } else if (artifact.action === "deleted") {
+      deleted.push(artifact.path);
+    }
+  }
+  if (created.length > 0) {
+    console.log(chalk.green("  Created:"));
+    for (const filePath of created) {
+      console.log(chalk.green(`    + ${filePath}`));
+      if (options.full) {
+        const fullPath = path.join(rootDir, filePath);
+        if (fs.existsSync(fullPath)) {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          const lines = content.split("\n").slice(0, 20);
+          for (const line of lines) {
+            console.log(chalk.gray(`      \u2502 ${line}`));
+          }
+          if (content.split("\n").length > 20) {
+            console.log(chalk.gray(`      \u2502 ... (${content.split("\n").length - 20} more lines)`));
+          }
+        }
+      }
+    }
+    console.log();
+  }
+  if (modified.length > 0) {
+    console.log(chalk.yellow("  Modified:"));
+    for (const filePath of modified) {
+      console.log(chalk.yellow(`    ~ ${filePath}`));
+    }
+    console.log();
+  }
+  if (deleted.length > 0) {
+    console.log(chalk.red("  Deleted:"));
+    for (const filePath of deleted) {
+      console.log(chalk.red(`    - ${filePath}`));
+    }
+    console.log();
+  }
+  console.log(chalk.gray("\u2500".repeat(60)));
+  console.log(chalk.gray(`  Summary: ${created.length} created, ${modified.length} modified, ${deleted.length} deleted`));
+  console.log();
+  if (orch.status === "completed") {
+    console.log(chalk.cyan("  Actions:"));
+    console.log(chalk.gray(`    paradigm team accept ${orch.id}  # Accept these changes`));
+    console.log(chalk.gray(`    paradigm team reject ${orch.id}  # Reject and cleanup`));
+    console.log();
+  }
+}
+export {
+  teamDiffCommand
+};