@a-company/paradigm 1.5.0

package/dist/chunk-TAP5N3HH.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+// src/core/provider-registry.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var providers = /* @__PURE__ */ new Map();
+var defaultProviderName = null;
+var initialized = false;
+var PROVIDER_PRIORITY = ["claude", "claude-code-teams", "claude-code", "cursor-cli", "claude-cli", "manual"];
+var VALID_PROVIDERS = ["auto", ...PROVIDER_PRIORITY];
+var configuredProvider = null;
+function registerProvider(provider) {
+  providers.set(provider.name, provider);
+}
+function getProvider(name) {
+  if (name && providers.has(name)) {
+    return providers.get(name) || null;
+  }
+  if (defaultProviderName && providers.has(defaultProviderName)) {
+    return providers.get(defaultProviderName) || null;
+  }
+  return null;
+}
+function getConfiguredProvider(rootDir) {
+  const envProvider = process.env.PARADIGM_AGENT_PROVIDER;
+  if (envProvider && VALID_PROVIDERS.includes(envProvider)) {
+    return envProvider;
+  }
+  if (configuredProvider !== null) {
+    return configuredProvider;
+  }
+  const dir = rootDir || process.cwd();
+  const configPath = path.join(dir, ".paradigm", "config.yaml");
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const config = yaml.load(content);
+      const provider = config["agent-provider"];
+      if (provider && VALID_PROVIDERS.includes(provider)) {
+        configuredProvider = provider;
+        return provider;
+      }
+    } catch {
+    }
+  }
+  return "auto";
+}
+async function setConfiguredProvider(provider, rootDir) {
+  if (!VALID_PROVIDERS.includes(provider)) {
+    throw new Error(`Invalid provider: ${provider}. Valid options: ${VALID_PROVIDERS.join(", ")}`);
+  }
+  const dir = rootDir || process.cwd();
+  const configPath = path.join(dir, ".paradigm", "config.yaml");
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      config = yaml.load(content);
+    } catch {
+    }
+  }
+  config["agent-provider"] = provider;
+  configuredProvider = provider;
+  const paradigmDir = path.dirname(configPath);
+  if (!fs.existsSync(paradigmDir)) {
+    fs.mkdirSync(paradigmDir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, yaml.dump(config));
+}
+async function getBestProvider(rootDir, explicitProvider) {
+  await initializeProviders(rootDir);
+  const configured = explicitProvider || getConfiguredProvider(rootDir);
+  const isExplicit = configured !== "auto";
+  if (isExplicit) {
+    const provider = providers.get(configured);
+    if (provider) {
+      try {
+        const available = await provider.isAvailable();
+        if (available) {
+          return {
+            provider,
+            name: configured,
+            reason: `Configured: ${getProviderReason(configured)}`,
+            configured: true
+          };
+        }
+      } catch {
+      }
+      console.warn(`Configured provider '${configured}' not available, falling back...`);
+    }
+  }
+  for (const name of PROVIDER_PRIORITY) {
+    const provider = providers.get(name);
+    if (!provider) continue;
+    try {
+      const available = await provider.isAvailable();
+      if (available) {
+        return {
+          provider,
+          name,
+          reason: isExplicit ? `Fallback: ${getProviderReason(name)} (configured '${configured}' unavailable)` : getProviderReason(name),
+          configured: false
+        };
+      }
+    } catch {
+    }
+  }
+  throw new Error("No providers available");
+}
+async function getAvailableProviders(rootDir) {
+  await initializeProviders(rootDir);
+  const results = [];
+  for (const name of PROVIDER_PRIORITY) {
+    const provider = providers.get(name);
+    if (!provider) continue;
+    let available = false;
+    try {
+      available = await provider.isAvailable();
+    } catch {
+    }
+    results.push({
+      name,
+      available,
+      reason: available ? getProviderReason(name) : getProviderUnavailableReason(name),
+      features: {
+        parallel: provider.supportsParallel(),
+        mcp: provider.supportsMcp(),
+        billing: getProviderBilling(name)
+      }
+    });
+  }
+  return results;
+}
+async function initializeProviders(rootDir) {
+  if (initialized) return;
+  const dir = rootDir || process.cwd();
+  try {
+    const { ClaudeAgentProvider } = await import("./claude-SUYNN72C.js");
+    registerProvider(new ClaudeAgentProvider());
+  } catch {
+  }
+  try {
+    const { ClaudeCodeTeamsProvider } = await import("./claude-code-teams-JLZ5IXB6.js");
+    registerProvider(new ClaudeCodeTeamsProvider(dir));
+  } catch {
+  }
+  try {
+    const { ClaudeCodeTaskProvider } = await import("./claude-code-PW6SKD2M.js");
+    registerProvider(new ClaudeCodeTaskProvider(dir));
+  } catch {
+  }
+  try {
+    const { CursorCliProvider } = await import("./cursor-cli-IHJMPRCW.js");
+    registerProvider(new CursorCliProvider());
+  } catch {
+  }
+  try {
+    const { ClaudeCliProvider } = await import("./claude-cli-OF43XAO3.js");
+    registerProvider(new ClaudeCliProvider());
+  } catch {
+  }
+  try {
+    const { ManualProvider } = await import("./manual-Y3QOXWYA.js");
+    registerProvider(new ManualProvider(dir));
+  } catch {
+  }
+  for (const name of PROVIDER_PRIORITY) {
+    const provider = providers.get(name);
+    if (provider) {
+      try {
+        const available = await provider.isAvailable();
+        if (available) {
+          defaultProviderName = name;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!defaultProviderName && providers.has("manual")) {
+    defaultProviderName = "manual";
+  }
+  initialized = true;
+}
+function getProviderReason(name) {
+  switch (name) {
+    case "claude":
+      return "Using Anthropic API (ANTHROPIC_API_KEY found)";
+    case "claude-code-teams":
+      return "Using Claude Code Agent Teams (experimental, parallel teammates)";
+    case "claude-code":
+      return "Using Claude Code Task tool (running in Claude Code)";
+    case "cursor-cli":
+      return "Using Cursor agent CLI (running in Cursor)";
+    case "claude-cli":
+      return "Using Claude CLI (claude command found)";
+    case "manual":
+      return "Using manual handoff (no automation available)";
+    default:
+      return "Unknown provider";
+  }
+}
+function getProviderUnavailableReason(name) {
+  switch (name) {
+    case "claude":
+      return "ANTHROPIC_API_KEY not set";
+    case "claude-code-teams":
+      return "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS not set or not in Claude Code";
+    case "claude-code":
+      return "Not running inside Claude Code";
+    case "cursor-cli":
+      return "Not running in Cursor or agent CLI not found";
+    case "claude-cli":
+      return "claude CLI not found in PATH";
+    case "manual":
+      return "Should always be available";
+    default:
+      return "Unknown";
+  }
+}
+function getProviderBilling(name) {
+  switch (name) {
+    case "claude":
+      return "api";
+    case "claude-code-teams":
+    case "claude-code":
+    case "cursor-cli":
+    case "claude-cli":
+      return "subscription";
+    case "manual":
+      return "none";
+    default:
+      return "none";
+  }
+}
+
+export {
+  getProvider,
+  getConfiguredProvider,
+  setConfiguredProvider,
+  getBestProvider,
+  getAvailableProviders,
+  initializeProviders
+};

package/dist/chunk-THFVK5AE.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import {
+  detectIDE,
+  getAdapter,
+  getAdapterNames,
+  loadParadigmFiles,
+  syncToAllIDEs,
+  syncToIDE,
+  writeMcpConfig,
+  writeNestedContexts
+} from "./chunk-YDNKXH4Z.js";
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+
+// src/commands/sync.ts
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function syncCommand(ide, options) {
+  const rootDir = process.cwd();
+  const spinner = ora();
+  const targetIde = options.target || ide;
+  const quiet = options.quiet;
+  if (!quiet) {
+    console.log(chalk.blue("\n\u{1F504} Paradigm Sync\n"));
+  }
+  if (!quiet) spinner.start("Loading .paradigm/ configuration...");
+  const files = loadParadigmFiles(rootDir);
+  if (!files) {
+    if (!quiet) {
+      spinner.fail("No .paradigm/ directory found");
+      console.log(chalk.gray("\nRun `paradigm init` to initialize Paradigm in this project.\n"));
+    }
+    log.command("sync").error("Missing .paradigm/ directory");
+    if (!quiet) process.exit(1);
+    throw new Error("No .paradigm/ directory found");
+  }
+  if (!quiet) spinner.succeed(`Loaded configuration for ${chalk.cyan(files.projectName)}`);
+  log.command("sync").debug("Configuration loaded", { projectName: files.projectName });
+  if (options.all) {
+    console.log(chalk.gray("\nSyncing to all IDEs...\n"));
+    const tracker2 = log.operation("sync-all").start("Syncing to all IDEs");
+    const results = syncToAllIDEs(rootDir, files, options.force);
+    for (const result2 of results) {
+      if (result2.success) {
+        console.log(chalk.green(`  \u2713 ${result2.ide}`), chalk.gray(`\u2192 ${result2.outputPath}`));
+        log.operation(`sync-${result2.ide}`).success("IDE files generated", { path: result2.outputPath });
+      } else {
+        console.log(chalk.red(`  \u2717 ${result2.ide}`), chalk.gray(`\u2192 ${result2.message}`));
+        log.operation(`sync-${result2.ide}`).error("Sync failed", { message: result2.message });
+      }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    console.log(chalk.gray(`
+${successCount}/${results.length} IDE files generated.`));
+    if (successCount === results.length) {
+      tracker2.success("All IDE files generated", { count: results.length });
+    } else {
+      tracker2.error("Some IDE syncs failed", { success: successCount, total: results.length });
+    }
+    if (options.mcp !== false) {
+      console.log("");
+      const ideNames = getAdapterNames();
+      for (const name of ideNames) {
+        const adapter2 = getAdapter(name);
+        if (adapter2?.generateMcpConfig) {
+          const mcpResult = writeMcpConfig(rootDir, name);
+          if (mcpResult.success) {
+            console.log(chalk.green(`  \u2713 MCP config for ${name}`), chalk.gray(`\u2192 ${path.relative(rootDir, mcpResult.path)}`));
+            log.component("mcp-config").success("MCP config generated", { ide: name, path: mcpResult.path });
+          }
+        }
+      }
+    }
+    console.log("");
+    return;
+  }
+  let finalTargetIde = targetIde;
+  if (!finalTargetIde) {
+    if (!quiet) spinner.start("Auto-detecting IDE...");
+    const detection = detectIDE(rootDir);
+    if (detection.detected) {
+      finalTargetIde = detection.detected;
+      if (!quiet) spinner.succeed(`Detected ${chalk.cyan(finalTargetIde)} (${detection.reason})`);
+    } else {
+      if (!quiet) spinner.warn("Could not auto-detect IDE, defaulting to Cursor");
+      finalTargetIde = "cursor";
+    }
+  }
+  const adapter = getAdapter(finalTargetIde);
+  if (!adapter) {
+    if (!quiet) {
+      console.log(chalk.red(`
+\u274C Unknown IDE: ${finalTargetIde}`));
+      console.log(chalk.gray(`
+Available IDEs: ${getAdapterNames().join(", ")}
+`));
+    }
+    log.command("sync").error("Unknown IDE", { ide: finalTargetIde, available: getAdapterNames() });
+    if (!quiet) process.exit(1);
+    throw new Error(`Unknown IDE: ${finalTargetIde}`);
+  }
+  const isMultiFile = adapter.multiFile;
+  if (!quiet) spinner.start(`Generating ${isMultiFile ? adapter.outputPath + "/" : adapter.outputPath}...`);
+  const tracker = log.operation(`sync-${finalTargetIde}`).start("Syncing IDE files", { ide: finalTargetIde });
+  const result = syncToIDE(rootDir, finalTargetIde, files, options.force);
+  if (result.success) {
+    if (!quiet) {
+      spinner.succeed(chalk.green(result.message));
+      console.log(chalk.gray(`
+  Path: ${result.outputPath}`));
+      if (isMultiFile && adapter.generateFiles) {
+        const generatedFiles = adapter.generateFiles(files);
+        for (const file of generatedFiles) {
+          console.log(chalk.gray(`    \u2514\u2500 ${file.path}`));
+        }
+      }
+    }
+    tracker.success("IDE files generated", { ide: finalTargetIde, path: result.outputPath });
+    if (options.mcp !== false && adapter.generateMcpConfig) {
+      const mcpResult = writeMcpConfig(rootDir, finalTargetIde);
+      if (mcpResult.success) {
+        if (!quiet) console.log(chalk.green(`
+  \u2713 ${mcpResult.message}`));
+        log.component("mcp-config").success("MCP config generated", { ide: finalTargetIde, path: mcpResult.path });
+      }
+    }
+    if (options.nested && adapter.generateNestedContexts) {
+      const nestedResult = writeNestedContexts(rootDir, finalTargetIde, files);
+      if (nestedResult.success && nestedResult.count > 0) {
+        if (!quiet) console.log(chalk.green(`
+  \u2713 ${nestedResult.message}`));
+        log.component("nested-contexts").success("Nested contexts generated", { ide: finalTargetIde, count: nestedResult.count });
+      }
+    }
+    if (!quiet) console.log("");
+  } else {
+    if (!quiet) spinner.fail(chalk.red(result.message));
+    tracker.error("Sync failed", { ide: finalTargetIde, message: result.message });
+    if (!quiet) process.exit(1);
+    throw new Error(result.message || "Sync failed");
+  }
+}
+
+export {
+  syncCommand
+};