@mutagent/cli 0.1.9 → 0.1.10

package/dist/bin/cli.js

@@ -19,10 +19,10 @@ var __toESM = (mod, isNodeMode, target) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/bin/cli.ts
-import { Command as Command11 } from "commander";
-import chalk12 from "chalk";
-import { readFileSync as readFileSync11 } from "fs";
-import { join as join2, dirname } from "path";
+import { Command as Command12 } from "commander";
+import chalk13 from "chalk";
+import { readFileSync as readFileSync12 } from "fs";
+import { join as join3, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/auth.ts
@@ -211,8 +211,22 @@ class AuthenticationError extends MutagentError {
 }
 
 class ApiError extends MutagentError {
+  statusCode;
   constructor(status, message) {
     super(`API_${status}`, message, status === 401 ? "Check your API key with: mutagent auth status" : undefined, 1);
+    this.statusCode = status;
+  }
+}
+var WORKSPACE_REMEDIATION_MESSAGE = [
+  "Workspace context missing. To fix:",
+  "  mutagent config set workspace <workspace-id>   # Set default workspace",
+  "  mutagent workspaces list                        # List available workspaces"
+].join(`
+`);
+
+class WorkspaceContextError extends MutagentError {
+  constructor(message) {
+    super("WORKSPACE_CONTEXT_MISSING", message ?? "Workspace context is required but not configured", "Run: mutagent config set workspace <workspace-id>", 3);
   }
 }
 
@@ -232,12 +246,33 @@ function handleError(error, isJson) {
           ciCd: "mutagent auth login --api-key <key>"
         };
       }
+      if (error instanceof WorkspaceContextError) {
+        jsonOutput.remediation = {
+          setWorkspace: "mutagent config set workspace <workspace-id>",
+          listWorkspaces: "mutagent workspaces list"
+        };
+      }
+      if (error instanceof ApiError && error.statusCode === 403) {
+        jsonOutput.remediation = {
+          interactive: "mutagent auth login --browser",
+          nonInteractive: "export MUTAGENT_API_KEY=<your-key>",
+          checkPermissions: "Verify your API key has the required permissions"
+        };
+      }
       console.log(JSON.stringify(jsonOutput, null, 2));
     } else {
       console.error(`Error: ${error.message}`);
       if (error instanceof AuthenticationError) {
         console.error("");
         console.error(AUTH_REMEDIATION_MESSAGE);
+      } else if (error instanceof WorkspaceContextError) {
+        console.error("");
+        console.error(WORKSPACE_REMEDIATION_MESSAGE);
+      } else if (error instanceof ApiError && error.statusCode === 403) {
+        console.error("");
+        console.error("Access denied. To fix:");
+        console.error("  mutagent auth login --browser    # Re-authenticate");
+        console.error("  export MUTAGENT_API_KEY=mt_xxx   # Or use a different API key");
       } else if (error instanceof ValidationError) {
         if (error.suggestion) {
           console.error(`Suggestion: ${error.suggestion}`);
@@ -313,6 +348,13 @@ class SDKClientWrapper {
       if (err.statusCode === 401) {
         throw new AuthenticationError;
       }
+      if (err.statusCode === 403) {
+        throw new ApiError(403, err.message ?? err.body ?? "Access denied");
+      }
+      const errMessage = (err.message ?? err.body ?? "").toLowerCase();
+      if (errMessage.includes("workspace") && (errMessage.includes("missing") || errMessage.includes("required")) || errMessage.includes("x-workspace-id")) {
+        throw new WorkspaceContextError(err.message ?? err.body ?? undefined);
+      }
       if (err.statusCode) {
         throw new ApiError(err.statusCode, err.message ?? err.body ?? "Unknown error");
       }
@@ -359,7 +401,14 @@ class SDKClientWrapper {
       if (response.status === 401) {
         throw new AuthenticationError;
       }
+      if (response.status === 403) {
+        throw new ApiError(403, await response.text() || "Access denied");
+      }
       const error = await response.text();
+      const errorLower = error.toLowerCase();
+      if (errorLower.includes("workspace") && (errorLower.includes("missing") || errorLower.includes("required")) || errorLower.includes("x-workspace-id")) {
+        throw new WorkspaceContextError(error);
+      }
       throw new ApiError(response.status, error);
     }
     return response.json();
@@ -754,7 +803,14 @@ class SDKClientWrapper {
       if (response.status === 401) {
         throw new AuthenticationError;
       }
+      if (response.status === 403) {
+        throw new ApiError(403, await response.text() || "Access denied");
+      }
       const error = await response.text();
+      const errorLower = error.toLowerCase();
+      if (errorLower.includes("workspace") && (errorLower.includes("missing") || errorLower.includes("required")) || errorLower.includes("x-workspace-id")) {
+        throw new WorkspaceContextError(error);
+      }
       throw new ApiError(response.status, error);
     }
     return response;
@@ -1580,10 +1636,10 @@ function promptLinks(promptId) {
 
 // src/commands/prompts.ts
 var PREREQUISITES_TEXT = `
-${chalk4.yellow("Prerequisites (all required):")}
-  1. LLM Provider configured     ${chalk4.dim("mutagent providers list")}
-  2. Evaluation criteria defined  ${chalk4.dim("(via dashboard or evaluation create)")}
-  3. Dataset uploaded             ${chalk4.dim("mutagent prompts dataset list <prompt-id>")}`;
+${chalk4.yellow("Prerequisites:")}
+  1. Evaluation criteria defined  ${chalk4.dim("(via dashboard or evaluation create)")}
+  2. Dataset uploaded             ${chalk4.dim("mutagent prompts dataset list <prompt-id>")}
+  ${chalk4.dim("Note: LLM provider config is only required when the server uses external providers (USE_EXT_PROVIDERS=true)")}`;
 function parseValidationErrors(error) {
   if (error instanceof ApiError) {
     try {
@@ -1613,14 +1669,6 @@ function warnSingleBraceVariables(content, output) {
     }
   }
 }
-async function checkProviderConfigured() {
-  const client = getSDKClient();
-  const providers = await client.listProviders();
-  if (providers.data.length === 0) {
-    throw new MutagentError("NO_PROVIDER", "No LLM provider configured. Evaluations and optimizations require at least one active provider.", `Configure a provider at: ${providerSettingsLink()}
-  Or check: mutagent providers list`);
-  }
-}
 function parseDatasetFile(rawContent, filePath) {
   const trimmed = rawContent.trim();
   if (filePath.endsWith(".csv")) {
@@ -2149,7 +2197,6 @@ ${chalk4.dim("Monitor progress with: mutagent prompts optimize status <job-id>")
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
-      await checkProviderConfigured();
       const client = getSDKClient();
       const job = await client.startOptimization(promptId, options.dataset, {
         maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : undefined,
@@ -4523,15 +4570,308 @@ Available Models:`));
   return providers;
 }
 
+// src/commands/init.ts
+import { Command as Command11 } from "commander";
+import inquirer3 from "inquirer";
+import chalk12 from "chalk";
+import { existsSync as existsSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join2 } from "path";
+var FRAMEWORK_DETECTION_MAP = {
+  "@mastra/core": {
+    name: "mastra",
+    displayName: "Mastra",
+    npmPackage: "@mastra/core"
+  },
+  "@langchain/langgraph": {
+    name: "langgraph",
+    displayName: "LangGraph",
+    npmPackage: "@langchain/langgraph",
+    mutagentPackage: "@mutagent/langgraph"
+  },
+  langchain: {
+    name: "langchain",
+    displayName: "LangChain",
+    npmPackage: "langchain",
+    mutagentPackage: "@mutagent/langchain"
+  },
+  "@langchain/core": {
+    name: "langchain",
+    displayName: "LangChain",
+    npmPackage: "@langchain/core",
+    mutagentPackage: "@mutagent/langchain"
+  },
+  "@ai-sdk/core": {
+    name: "vercel-ai",
+    displayName: "Vercel AI SDK",
+    npmPackage: "@ai-sdk/core",
+    mutagentPackage: "@mutagent/vercel-ai"
+  },
+  ai: {
+    name: "vercel-ai",
+    displayName: "Vercel AI SDK",
+    npmPackage: "ai",
+    mutagentPackage: "@mutagent/vercel-ai"
+  },
+  "@google/genai": {
+    name: "generic",
+    displayName: "Google GenAI",
+    npmPackage: "@google/genai"
+  },
+  openai: {
+    name: "openai",
+    displayName: "OpenAI SDK",
+    npmPackage: "openai",
+    mutagentPackage: "@mutagent/openai"
+  }
+};
+function detectPackageManager2(cwd = process.cwd()) {
+  if (existsSync10(join2(cwd, "bun.lockb")) || existsSync10(join2(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  if (existsSync10(join2(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync10(join2(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync10(join2(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  try {
+    execSync2("bun --version", { stdio: "ignore" });
+    return "bun";
+  } catch {
+    return "npm";
+  }
+}
+function getInstallCommand2(pm, packages) {
+  const pkgList = packages.join(" ");
+  const commands = {
+    bun: `bun add ${pkgList}`,
+    npm: `npm install ${pkgList}`,
+    yarn: `yarn add ${pkgList}`,
+    pnpm: `pnpm add ${pkgList}`
+  };
+  return commands[pm];
+}
+function detectFrameworkFromPackageJson(cwd = process.cwd()) {
+  const pkgPath = join2(cwd, "package.json");
+  if (!existsSync10(pkgPath)) {
+    return null;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  for (const [depName, framework] of Object.entries(FRAMEWORK_DETECTION_MAP)) {
+    if (depName in allDeps) {
+      return framework;
+    }
+  }
+  return null;
+}
+function hasRcConfig(cwd = process.cwd()) {
+  return existsSync10(join2(cwd, ".mutagentrc.json"));
+}
+function writeRcConfig(config, cwd = process.cwd()) {
+  const rcPath = join2(cwd, ".mutagentrc.json");
+  writeFileSync3(rcPath, JSON.stringify(config, null, 2) + `
+`);
+}
+function createInitCommand() {
+  const init = new Command11("init").description("Initialize MutagenT in your project").option("--non-interactive", "Skip interactive prompts (defaults to CLI-only mode)").addHelpText("after", `
+Examples:
+  ${chalk12.dim("$")} mutagent init                     # Interactive setup wizard
+  ${chalk12.dim("$")} mutagent init --non-interactive    # CLI-only mode (no prompts)
+
+Modes:
+  ${chalk12.bold("Full scaffold")}     Install SDK + integration package, create config, setup tracing
+  ${chalk12.bold("CLI-only")}          Verify auth + create .mutagentrc.json with workspace/endpoint
+  ${chalk12.bold("Skip")}              Exit without changes
+    `).action(async (options) => {
+    const isJson = getJsonFlag(init);
+    const output = new OutputFormatter(isJson ? "json" : "table");
+    try {
+      const isNonInteractive = options.nonInteractive === true || process.env.MUTAGENT_NON_INTERACTIVE === "true" || process.env.CI === "true" || !process.stdin.isTTY;
+      const cwd = process.cwd();
+      if (hasRcConfig(cwd)) {
+        output.warn(".mutagentrc.json already exists in this directory.");
+        if (isNonInteractive) {
+          output.info("Use --force to overwrite (not yet supported). Exiting.");
+          return;
+        }
+        const { overwrite } = await inquirer3.prompt([{
+          type: "confirm",
+          name: "overwrite",
+          message: ".mutagentrc.json already exists. Overwrite?",
+          default: false
+        }]);
+        if (!overwrite) {
+          output.info("Init cancelled.");
+          return;
+        }
+      }
+      const authenticated = hasCredentials();
+      if (!authenticated) {
+        output.warn("Not authenticated.");
+        output.info("Run: mutagent auth login --browser");
+        if (isNonInteractive) {
+          throw new MutagentError("AUTH_REQUIRED", "Authentication required before init", "Run: mutagent auth login --browser");
+        }
+        const { doAuth } = await inquirer3.prompt([{
+          type: "confirm",
+          name: "doAuth",
+          message: "Would you like to authenticate now?",
+          default: true
+        }]);
+        if (doAuth) {
+          output.info('Run "mutagent auth login --browser" and then re-run "mutagent init".');
+          return;
+        }
+      }
+      const detectedFramework = detectFrameworkFromPackageJson(cwd);
+      let mode;
+      let confirmedFramework = detectedFramework;
+      if (isNonInteractive) {
+        mode = "cli-only";
+        if (isJson) {
+          output.output({
+            mode: "cli-only",
+            nonInteractive: true,
+            detectedFramework: detectedFramework?.name ?? null
+          });
+        }
+      } else {
+        if (detectedFramework) {
+          output.info(`Detected framework: ${detectedFramework.displayName} (${detectedFramework.npmPackage})`);
+          const { confirmFramework } = await inquirer3.prompt([{
+            type: "confirm",
+            name: "confirmFramework",
+            message: `Use ${detectedFramework.displayName}?`,
+            default: true
+          }]);
+          if (!confirmFramework) {
+            const frameworkChoices = [
+              { name: "Mastra", value: "mastra" },
+              { name: "LangChain", value: "langchain" },
+              { name: "LangGraph", value: "langgraph" },
+              { name: "Vercel AI SDK", value: "vercel-ai" },
+              { name: "OpenAI SDK", value: "openai" },
+              { name: "Generic (OpenAI-compatible)", value: "generic" },
+              { name: "None / Skip framework", value: "none" }
+            ];
+            const { selectedFramework } = await inquirer3.prompt([{
+              type: "list",
+              name: "selectedFramework",
+              message: "Select your AI framework:",
+              choices: frameworkChoices
+            }]);
+            if (selectedFramework === "none") {
+              confirmedFramework = null;
+            } else {
+              const entry = Object.values(FRAMEWORK_DETECTION_MAP).find((f) => f.name === selectedFramework);
+              confirmedFramework = entry ?? null;
+            }
+          }
+        } else {
+          output.info("No AI framework detected in package.json.");
+        }
+        const modeChoices = [
+          ...confirmedFramework?.mutagentPackage ? [{
+            name: `Full scaffold - Install @mutagent/sdk + ${confirmedFramework.mutagentPackage}, create config, setup tracing`,
+            value: "full"
+          }] : [],
+          {
+            name: "CLI-only - Verify auth + create .mutagentrc.json config",
+            value: "cli-only"
+          },
+          {
+            name: "Skip - Exit without changes",
+            value: "skip"
+          }
+        ];
+        const { selectedMode } = await inquirer3.prompt([{
+          type: "list",
+          name: "selectedMode",
+          message: "How would you like to initialize MutagenT?",
+          choices: modeChoices
+        }]);
+        mode = selectedMode;
+      }
+      if (mode === "skip") {
+        output.info("Init skipped.");
+        return;
+      }
+      const config = loadConfig();
+      const endpoint = config.endpoint ?? "https://api.mutagent.io";
+      const workspace = config.defaultWorkspace;
+      const rcConfig = {
+        endpoint,
+        ...workspace ? { workspace } : {},
+        ...confirmedFramework ? { framework: confirmedFramework.name } : {}
+      };
+      if (mode === "full" && confirmedFramework?.mutagentPackage) {
+        const pm = detectPackageManager2(cwd);
+        const packages = ["@mutagent/sdk", confirmedFramework.mutagentPackage];
+        const installCmd = getInstallCommand2(pm, packages);
+        output.info(`Installing: ${packages.join(", ")}`);
+        output.info(`Running: ${installCmd}`);
+        try {
+          execSync2(installCmd, { cwd, stdio: "inherit" });
+          output.success("Packages installed successfully.");
+        } catch {
+          output.error("Package installation failed. You can install manually:");
+          output.info(`  ${installCmd}`);
+        }
+        writeRcConfig(rcConfig, cwd);
+        output.success("Created .mutagentrc.json");
+        console.log("");
+        output.info("Next steps:");
+        output.info(`  1. Run: mutagent integrate ${confirmedFramework.name}`);
+        output.info("  2. Follow the integration guide to add tracing to your code");
+        output.info("  3. Run: mutagent traces list  (to verify traces are arriving)");
+      } else {
+        writeRcConfig(rcConfig, cwd);
+        output.success("Created .mutagentrc.json");
+        if (!authenticated) {
+          output.info("Next: mutagent auth login --browser");
+        } else {
+          output.info('Ready! Run "mutagent --help" to see available commands.');
+        }
+      }
+      if (isJson) {
+        output.output({
+          success: true,
+          mode,
+          configFile: ".mutagentrc.json",
+          config: rcConfig,
+          framework: confirmedFramework?.name ?? null,
+          authenticated
+        });
+      }
+    } catch (error) {
+      handleError(error, isJson);
+    }
+  });
+  return init;
+}
+
 // src/bin/cli.ts
 var cliVersion = "0.1.1";
 try {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
-  const pkgPath = join2(__dirname2, "..", "..", "package.json");
-  const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+  const pkgPath = join3(__dirname2, "..", "..", "package.json");
+  const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
   cliVersion = pkg.version ?? cliVersion;
 } catch {}
-var program = new Command11;
+var program = new Command12;
 program.name("mutagent").description(`MutagenT CLI - AI-native prompt optimization platform
 
   Documentation: https://docs.mutagent.io/cli
@@ -4540,43 +4880,45 @@ program.name("mutagent").description(`MutagenT CLI - AI-native prompt optimizati
   showGlobalOptions: true
 });
 program.addHelpText("after", `
-${chalk12.yellow("Non-Interactive Mode (CI/CD & Coding Agents):")}
-  Export your API key:     ${chalk12.green("export MUTAGENT_API_KEY=mt_your_key_here")}
-  Or pass inline:          ${chalk12.green("mutagent prompts list --api-key mt_your_key")}
-  Machine-readable output: ${chalk12.green("mutagent prompts list --json")}
-  Disable prompts:         ${chalk12.green("mutagent prompts list --non-interactive")}
-  Set default workspace:   ${chalk12.green("mutagent config set workspace <workspace-id>")}
-  Set default org:         ${chalk12.green("mutagent config set org <org-id>")}
+${chalk13.yellow("Non-Interactive Mode (CI/CD & Coding Agents):")}
+  Export your API key:     ${chalk13.green("export MUTAGENT_API_KEY=mt_your_key_here")}
+  Or pass inline:          ${chalk13.green("mutagent prompts list --api-key mt_your_key")}
+  Machine-readable output: ${chalk13.green("mutagent prompts list --json")}
+  Disable prompts:         ${chalk13.green("mutagent prompts list --non-interactive")}
+  Set default workspace:   ${chalk13.green("mutagent config set workspace <workspace-id>")}
+  Set default org:         ${chalk13.green("mutagent config set org <org-id>")}
 `);
 program.addHelpText("after", `
-${chalk12.yellow("Workflows:")}
-  ${chalk12.bold("Evaluate → Optimize Loop:")}
+${chalk13.yellow("Workflows:")}
+  ${chalk13.bold("Evaluate → Optimize Loop:")}
     1. mutagent prompts create --name "..." --raw-file prompt.txt
     2. mutagent prompts dataset add <prompt-id> --name "..." --file data.json
     3. mutagent prompts evaluation create <prompt-id> --name "..." --file criteria.json
     4. mutagent prompts optimize start <prompt-id> --dataset <id> --max-iterations 3
 
-  ${chalk12.bold("Quick Test:")}
+  ${chalk13.bold("Quick Test:")}
     mutagent playground run <prompt-id> --input '{"key":"value"}'
 
-  ${chalk12.bold("Prerequisites for Optimization:")}
-    ${chalk12.green("✓")} Prompt with input/output parameters
-    ${chalk12.green("✓")} Dataset with items (input + expectedOutput pairs)
-    ${chalk12.green("✓")} Evaluation with criteria (field-level, input/output focused)
-    ${chalk12.green("✓")} Configured LLM provider (https://app.mutagent.io/settings/providers)
+  ${chalk13.bold("Prerequisites for Optimization:")}
+    ${chalk13.green("✓")} Prompt with input/output parameters
+    ${chalk13.green("✓")} Dataset with items (input + expectedOutput pairs)
+    ${chalk13.green("✓")} Evaluation with criteria (field-level, input/output focused)
+    ${chalk13.dim("•")} LLM provider ${chalk13.dim("(only when server uses external providers)")}
 `);
 program.addHelpText("after", `
-${chalk12.cyan("┌─ AI AGENT INTEGRATION HINT ────────────────────────────────────────────────┐")}
-${chalk12.cyan("│")}                                                                            ${chalk12.cyan("│")}
-${chalk12.cyan("│")} Frameworks: mastra, langchain, langgraph, vercel-ai, claude-code, generic  ${chalk12.cyan("│")}
-${chalk12.cyan("│")}                                                                            ${chalk12.cyan("│")}
-${chalk12.cyan("│")} Get integration guide:  mutagent integrate <framework>                     ${chalk12.cyan("│")}
-${chalk12.cyan("│")} Verify setup:           mutagent integrate <framework> --verify            ${chalk12.cyan("│")}
-${chalk12.cyan("│")} Use --json for AI parsing:  mutagent <command> --json                      ${chalk12.cyan("│")}
-${chalk12.cyan("│")}                                                                            ${chalk12.cyan("│")}
-${chalk12.cyan("└────────────────────────────────────────────────────────────────────────────┘")}
-${!hasCredentials() ? chalk12.yellow(`
+${chalk13.cyan("┌─ AI AGENT INTEGRATION HINT ────────────────────────────────────────────────┐")}
+${chalk13.cyan("│")}                                                                            ${chalk13.cyan("│")}
+${chalk13.cyan("│")} Frameworks: mastra, langchain, langgraph, vercel-ai, claude-code, generic  ${chalk13.cyan("│")}
+${chalk13.cyan("│")}                                                                            ${chalk13.cyan("│")}
+${chalk13.cyan("│")} Get integration guide:  mutagent integrate <framework>                     ${chalk13.cyan("│")}
+${chalk13.cyan("│")} Verify setup:           mutagent integrate <framework> --verify            ${chalk13.cyan("│")}
+${chalk13.cyan("│")} Use --json for AI parsing:  mutagent <command> --json                      ${chalk13.cyan("│")}
+${chalk13.cyan("│")}                                                                            ${chalk13.cyan("│")}
+${chalk13.cyan("└────────────────────────────────────────────────────────────────────────────┘")}
+${!hasCredentials() ? chalk13.yellow(`
   Warning: Not authenticated. Run: mutagent auth login --browser
+`) : ""}${!hasRcConfig() ? chalk13.green(`
+  Get started: mutagent init
 `) : ""}`);
 program.hook("preAction", (thisCommand) => {
   const globalOpts = thisCommand.optsWithGlobals();
@@ -4590,6 +4932,7 @@ program.hook("preAction", (thisCommand) => {
     process.env.MUTAGENT_NON_INTERACTIVE = "true";
   }
 });
+program.addCommand(createInitCommand());
 program.addCommand(createLoginCommand());
 program.addCommand(createAuthCommand());
 program.addCommand(createConfigCommand());
@@ -4602,5 +4945,5 @@ program.addCommand(createWorkspacesCommand());
 program.addCommand(createProvidersCommand());
 program.parse();
 
-//# debugId=4E442D79ABA4A46A64756E2164756E21
+//# debugId=BAA438F82E7B39A164756E2164756E21
 //# sourceMappingURL=cli.js.map