@01.software/init 0.5.1 → 0.7.0

package/dist/index.js

@@ -3,9 +3,15 @@ import {
   fetchTenantContext,
   generateClaudeMd,
   getSkillFiles
-} from "./chunk-SRLZ5OIV.js";
+} from "./chunk-T3A5SLEJ.js";
+import {
+  readEnvValue,
+  replaceTomlMcpSection,
+  setEnvValue
+} from "./chunk-JT3G6B66.js";
 import {
   CODEX_MCP_SECTION_MARKER,
+  getAnalyticsTemplate,
   getClientTemplate,
   getCodexMcpTomlSection,
   getEnvContent,
@@ -13,7 +19,7 @@ import {
   getMcpServerEntry,
   getQueryProviderTemplate,
   getServerTemplate
-} from "./chunk-OEAQV63E.js";
+} from "./chunk-S3KHPWCE.js";
 
 // src/index.ts
 import pc3 from "picocolors";
@@ -26,19 +32,29 @@ function detectProject(cwd) {
   const hasPackageJson = fs.existsSync(pkgPath);
   let env = "node";
   let hasSdk = false;
+  let hasReactQuery = false;
   let parseError = false;
   if (hasPackageJson) {
     let pkg;
     try {
       pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
     } catch {
-      return { hasPackageJson: true, parseError: true, env: "node", packageManager: null, hasSdk: false, srcDir: false };
+      return {
+        hasPackageJson: true,
+        parseError: true,
+        env: "node",
+        packageManager: null,
+        hasSdk: false,
+        hasReactQuery: false,
+        srcDir: false
+      };
     }
     const deps = {
       ...pkg.dependencies || {},
       ...pkg.devDependencies || {}
     };
     hasSdk = "@01.software/sdk" in deps;
+    hasReactQuery = "@tanstack/react-query" in deps;
     if ("next" in deps) {
       env = "nextjs";
     } else if ("astro" in deps || "@astrojs/node" in deps) {
@@ -68,7 +84,7 @@ function detectProject(cwd) {
     packageManager = "npm";
   }
   const srcDir = env === "nextjs" ? fs.existsSync(path.join(cwd, "src", "app")) : fs.existsSync(path.join(cwd, "src"));
-  return { hasPackageJson, parseError, env, packageManager, hasSdk, srcDir };
+  return { hasPackageJson, parseError, env, packageManager, hasSdk, hasReactQuery, srcDir };
 }
 function needsClient(env) {
   return env === "nextjs" || env === "react-vite" || env === "react-cra" || env === "vanilla";
@@ -224,7 +240,7 @@ async function promptUser(hasSdk, detectedEnv, detectedPm) {
       {
         type: "select",
         name: "method",
-        message: "API keys:",
+        message: "SDK credentials:",
         choices: [
           { title: "Browser login (recommended)", value: "browser" },
           { title: "Enter manually", value: "manual" },
@@ -259,6 +275,7 @@ import path2 from "path";
 import os from "os";
 import { execSync } from "child_process";
 import pc2 from "picocolors";
+import prompts2 from "prompts";
 
 // src/browser-auth.ts
 import { randomBytes } from "crypto";
@@ -447,56 +464,57 @@ async function init(cwd, info, answers) {
   const wantsClient = needsClient(env);
   const wantsServer = needsServer(env);
   const wantsReactQuery = needsReactQuery(env);
-  const deps = ["@01.software/sdk"];
-  if (wantsReactQuery) deps.push("@tanstack/react-query");
-  const addCmd = buildAddCmd(packageManager, hasPnpmWorkspace(cwd), deps);
-  let installFailed = false;
-  console.log(pc2.dim(`  Installing ${deps.join(" and ")}...`));
-  const wsPatched = packageManager === "pnpm" && patchPnpmWorkspace(cwd);
-  try {
-    execSync(addCmd, { cwd, stdio: "pipe" });
-    console.log(pc2.green("  Installed"), deps.join(", "));
-  } catch (error) {
-    installFailed = true;
-    const err = error;
-    const msg = String(err.stderr || "").trim() || String(err.stdout || "").trim() || String(error);
-    console.log(pc2.yellow("  Install failed \u2014 continuing with scaffolding"));
-    const firstLines = msg.split("\n").slice(0, 3).map((l) => `    ${l}`).join("\n");
-    if (firstLines) console.log(pc2.dim(firstLines));
-    console.log(pc2.dim(`    Run manually: ${addCmd}`));
-  } finally {
-    if (wsPatched) restorePnpmWorkspace(cwd);
+  const plan = await planConflictsAndEnv(cwd, baseDir, env, answers);
+  const installResult = installDeps(
+    cwd,
+    packageManager,
+    info.hasSdk,
+    info.hasReactQuery,
+    wantsReactQuery
+  );
+  if (wantsClient || wantsReactQuery || wantsServer) {
+    fs2.mkdirSync(path2.join(baseDir, "lib", "software"), { recursive: true });
   }
   const libDir = path2.join(baseDir, "lib", "software");
-  fs2.mkdirSync(libDir, { recursive: true });
   if (wantsClient) {
-    writeFileIfAbsent(
+    await writeFileWithPolicy(
       cwd,
       path2.join(libDir, "client.ts"),
-      getClientTemplate(env, publishableKeyEnvVar)
+      getClientTemplate(env, publishableKeyEnvVar),
+      plan.policy
+    );
+    await writeFileWithPolicy(
+      cwd,
+      path2.join(libDir, "analytics.ts"),
+      getAnalyticsTemplate(env, publishableKeyEnvVar),
+      plan.policy
     );
   }
   if (wantsReactQuery) {
-    writeFileIfAbsent(
+    await writeFileWithPolicy(
       cwd,
       path2.join(libDir, "query-provider.tsx"),
-      getQueryProviderTemplate(env)
+      getQueryProviderTemplate(env),
+      plan.policy
     );
   }
   if (wantsServer) {
-    writeFileIfAbsent(
+    await writeFileWithPolicy(
       cwd,
       path2.join(libDir, "server.ts"),
-      getServerTemplate(env, publishableKeyEnvVar, SECRET_KEY_ENV_VAR)
+      getServerTemplate(env, publishableKeyEnvVar, SECRET_KEY_ENV_VAR),
+      plan.policy
     );
   }
-  if (env !== "vanilla" && env !== "edge" && answers.authMethod !== "browser") {
-    writeEnv(
+  if (plan.envFile && answers.authMethod !== "browser") {
+    await writeEnv(
       cwd,
+      plan.envFile,
       answers.publishableKey || "",
       answers.secretKey || "",
       publishableKeyEnvVar,
-      wantsServer ? SECRET_KEY_ENV_VAR : null
+      wantsServer ? SECRET_KEY_ENV_VAR : null,
+      plan.policy
     );
   }
   let publishableKey = answers.publishableKey;
@@ -509,13 +527,15 @@ async function init(cwd, info, answers) {
       publishableKey = creds.publishableKey;
       secretKey = creds.secretKey;
       tenantName = creds.tenantName;
-      if (env !== "vanilla" && env !== "edge" && publishableKey) {
-        writeEnv(
+      if (plan.envFile && publishableKey) {
+        await writeEnv(
           cwd,
+          plan.envFile,
           publishableKey,
           secretKey,
           publishableKeyEnvVar,
           wantsServer ? SECRET_KEY_ENV_VAR : null,
+          "overwrite",
           true
         );
       }
@@ -527,16 +547,47 @@ async function init(cwd, info, answers) {
     }
   }
   if (answers.aiTools.length > 0) {
-    const apiKey = secretKey || "YOUR_API_KEY";
     for (const tool of answers.aiTools) {
-      writeMcpConfig(tool, cwd, apiKey);
+      await writeMcpConfig(tool, cwd);
     }
     addToGitignore(cwd, answers.aiTools);
     if (answers.aiTools.includes("claude")) {
-      await writeClaudeDocs(cwd, publishableKey, secretKey, tenantName);
+      await writeClaudeDocs(cwd, publishableKey, secretKey, tenantName, plan.policy);
     }
   }
-  return { installFailed, installCmd: addCmd };
+  return installResult;
+}
+function installDeps(cwd, pm, hasSdk, hasReactQuery, wantsReactQuery) {
+  const allDeps = [
+    { name: "@01.software/sdk", installed: hasSdk, needed: true },
+    { name: "@tanstack/react-query", installed: hasReactQuery, needed: wantsReactQuery }
+  ];
+  const fullList = allDeps.filter((d) => d.needed).map((d) => d.name);
+  const toInstall = allDeps.filter((d) => d.needed && !d.installed).map((d) => d.name);
+  const fullCmd = buildAddCmd(pm, hasPnpmWorkspace(cwd), fullList);
+  if (toInstall.length === 0) {
+    console.log(pc2.dim(`  Dependencies already installed: ${fullList.join(", ")}`));
+    return { installFailed: false, installSkipped: true, installCmd: fullCmd };
+  }
+  const addCmd = buildAddCmd(pm, hasPnpmWorkspace(cwd), toInstall);
+  console.log(pc2.dim(`  Installing ${toInstall.join(" and ")}...`));
+  const wsPatched = pm === "pnpm" && patchPnpmWorkspace(cwd);
+  let installFailed = false;
+  try {
+    execSync(addCmd, { cwd, stdio: "pipe" });
+    console.log(pc2.green("  Installed"), toInstall.join(", "));
+  } catch (error) {
+    installFailed = true;
+    const err = error;
+    const msg = String(err.stderr || "").trim() || String(err.stdout || "").trim() || String(error);
+    console.log(pc2.yellow("  Install failed \u2014 continuing with scaffolding"));
+    const firstLines = msg.split("\n").slice(0, 3).map((l) => `    ${l}`).join("\n");
+    if (firstLines) console.log(pc2.dim(firstLines));
+    console.log(pc2.dim(`    Run manually: ${addCmd}`));
+  } finally {
+    if (wsPatched) restorePnpmWorkspace(cwd);
+  }
+  return { installFailed, installSkipped: false, installCmd: addCmd };
 }
 function buildAddCmd(pm, hasPnpmWs, deps) {
   const pkgs = deps.join(" ");
@@ -551,34 +602,155 @@ function buildAddCmd(pm, hasPnpmWs, deps) {
       return `npm install ${pkgs}`;
   }
 }
-function writeFileIfAbsent(cwd, filePath, content) {
-  if (fs2.existsSync(filePath)) {
-    console.log(pc2.yellow("  Skipped"), relativePath(cwd, filePath), pc2.dim("(already exists)"));
+async function planConflictsAndEnv(cwd, baseDir, env, answers) {
+  const candidates = [];
+  const libDir = path2.join(baseDir, "lib", "software");
+  if (needsClient(env)) candidates.push(path2.join(libDir, "client.ts"));
+  if (needsReactQuery(env)) candidates.push(path2.join(libDir, "query-provider.tsx"));
+  if (needsServer(env)) candidates.push(path2.join(libDir, "server.ts"));
+  if (answers.aiTools.includes("claude")) {
+    for (const { dirName } of getSkillFiles()) {
+      candidates.push(path2.join(cwd, ".claude", "skills", dirName, "SKILL.md"));
+    }
+  }
+  const conflicts = candidates.filter((p) => fs2.existsSync(p));
+  let policy = "skip";
+  if (conflicts.length > 0) {
+    console.log(pc2.yellow(`  ${conflicts.length} file(s) already exist:`));
+    for (const c of conflicts) console.log(pc2.dim(`    ${path2.relative(cwd, c)}`));
+    const { selected } = await prompts2({
+      type: "select",
+      name: "selected",
+      message: "How should I handle existing files?",
+      choices: [
+        { title: "Keep existing (skip)", value: "skip" },
+        { title: "Overwrite all", value: "overwrite" },
+        { title: "Ask for each", value: "ask" }
+      ],
+      initial: 0
+    });
+    policy = selected ?? "skip";
+  }
+  const envFile = env === "vanilla" || env === "edge" ? "" : await pickEnvFile(cwd, env);
+  return { policy, envFile };
+}
+async function pickEnvFile(cwd, env) {
+  const candidates = [".env.local", ".env", ".env.development"];
+  const existing = candidates.filter((f) => fs2.existsSync(path2.join(cwd, f)));
+  const preferred = env === "nextjs" ? ".env.local" : ".env";
+  if (existing.length === 0) return preferred;
+  if (existing.length === 1 && existing[0] === preferred) return existing[0];
+  const options = Array.from(/* @__PURE__ */ new Set([...existing, preferred]));
+  const choices = options.map((f) => ({
+    title: f,
+    description: existing.includes(f) ? "exists" : "create",
+    value: f
+  }));
+  const initial = Math.max(
+    0,
+    choices.findIndex((c) => c.value === preferred)
+  );
+  const { file } = await prompts2({
+    type: "select",
+    name: "file",
+    message: "Which env file should I write SDK credentials to?",
+    choices,
+    initial
+  });
+  return file ?? preferred;
+}
+async function writeFileWithPolicy(cwd, filePath, content, policy) {
+  const rel = path2.relative(cwd, filePath);
+  if (!fs2.existsSync(filePath)) {
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+    fs2.writeFileSync(filePath, content);
+    console.log(pc2.green("  Created"), rel);
+    return;
+  }
+  const existing = fs2.readFileSync(filePath, "utf-8");
+  if (existing === content) {
+    console.log(pc2.dim("  Unchanged"), rel);
     return;
   }
-  fs2.writeFileSync(filePath, content);
-  console.log(pc2.green("  Created"), relativePath(cwd, filePath));
+  let shouldWrite = false;
+  if (policy === "overwrite") {
+    shouldWrite = true;
+  } else if (policy === "ask") {
+    const { confirm } = await prompts2({
+      type: "confirm",
+      name: "confirm",
+      message: `Overwrite ${rel}?`,
+      initial: false
+    });
+    shouldWrite = !!confirm;
+  }
+  if (shouldWrite) {
+    fs2.writeFileSync(filePath, content);
+    console.log(pc2.green("  Overwrote"), rel);
+  } else {
+    console.log(pc2.yellow("  Skipped"), rel, pc2.dim("(already exists)"));
+  }
 }
-function writeEnv(cwd, publishableKey, secretKey, publishableKeyEnvVar, secretKeyEnvVar, afterBrowserAuth = false) {
-  const envPath = path2.join(cwd, ".env");
-  const envContent = getEnvContent(publishableKey, secretKey, publishableKeyEnvVar, secretKeyEnvVar);
-  if (fs2.existsSync(envPath)) {
-    const existing = fs2.readFileSync(envPath, "utf-8");
-    if (existing.includes(publishableKeyEnvVar)) {
-      if (!afterBrowserAuth) {
-        console.log(pc2.yellow("  Skipped"), ".env", pc2.dim("(keys already present)"));
+async function writeEnv(cwd, envFile, publishableKey, secretKey, publishableKeyEnvVar, secretKeyEnvVar, policy, fromBrowserAuth = false) {
+  const envPath = path2.join(cwd, envFile);
+  const targets = [
+    { name: publishableKeyEnvVar, value: publishableKey }
+  ];
+  if (secretKeyEnvVar) {
+    targets.push({ name: secretKeyEnvVar, value: secretKey });
+  }
+  if (!fs2.existsSync(envPath)) {
+    const initial = getEnvContent(publishableKey, secretKey, publishableKeyEnvVar, secretKeyEnvVar);
+    fs2.writeFileSync(envPath, initial.trimStart());
+    console.log(pc2.green("  Created"), envFile);
+    return;
+  }
+  let content = fs2.readFileSync(envPath, "utf-8");
+  let modified = false;
+  let appendedHeader = false;
+  const headerAlreadyPresent = targets.some(
+    (t) => readEnvValue(content, t.name) !== null
+  );
+  for (const { name, value } of targets) {
+    const existing = readEnvValue(content, name);
+    if (existing === null) {
+      if (!headerAlreadyPresent && !appendedHeader) {
+        if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+        content += "\n# 01.software\n";
+        appendedHeader = true;
       }
-      return;
+      content = setEnvValue(content, name, value);
+      modified = true;
+      continue;
+    }
+    if (existing === value) continue;
+    if (!value) continue;
+    let shouldOverwrite = false;
+    if (policy === "overwrite") {
+      shouldOverwrite = true;
+    } else if (policy === "ask") {
+      const { confirm } = await prompts2({
+        type: "confirm",
+        name: "confirm",
+        message: `${name} already set in ${envFile}. Overwrite?`,
+        initial: fromBrowserAuth
+      });
+      shouldOverwrite = !!confirm;
+    }
+    if (shouldOverwrite) {
+      content = setEnvValue(content, name, value);
+      modified = true;
     }
-    fs2.appendFileSync(envPath, envContent);
+  }
+  if (modified) {
+    fs2.writeFileSync(envPath, content);
     console.log(
       pc2.green("  Updated"),
-      ".env",
-      afterBrowserAuth ? pc2.dim("(added API keys)") : ""
+      envFile,
+      fromBrowserAuth ? pc2.dim("(SDK credentials)") : ""
     );
   } else {
-    fs2.writeFileSync(envPath, envContent.trimStart());
-    console.log(pc2.green("  Created"), ".env");
+    console.log(pc2.dim("  Unchanged"), envFile);
   }
 }
 function resolveMcpLocation(tool, cwd) {
@@ -608,7 +780,13 @@ function resolveMcpLocation(tool, cwd) {
     case "windsurf": {
       if (!home) return null;
       const p = path2.join(home, ".codeium", "windsurf", "mcp_config.json");
-      return { kind: "json", absolutePath: p, displayPath: p, gitignoreEntry: null };
+      return {
+        kind: "json",
+        absolutePath: p,
+        jsonClient: "windsurf",
+        displayPath: p,
+        gitignoreEntry: null
+      };
     }
     case "codex": {
       if (!home) return null;
@@ -622,7 +800,7 @@ function resolveMcpLocation(tool, cwd) {
     }
   }
 }
-function writeMcpConfig(tool, cwd, apiKey) {
+async function writeMcpConfig(tool, cwd) {
   const loc = resolveMcpLocation(tool, cwd);
   if (!loc) {
     console.log(pc2.yellow(`  Skipped ${tool}`), pc2.dim("(HOME not set)"));
@@ -630,46 +808,55 @@ function writeMcpConfig(tool, cwd, apiKey) {
   }
   fs2.mkdirSync(path2.dirname(loc.absolutePath), { recursive: true });
   if (loc.kind === "json") {
-    writeJsonMcp(loc, apiKey);
+    writeJsonMcp(loc);
   } else {
-    writeTomlMcp(loc, apiKey);
+    writeTomlMcp(loc);
   }
 }
-function writeJsonMcp(loc, apiKey) {
-  if (fs2.existsSync(loc.absolutePath)) {
-    try {
-      const existing = JSON.parse(fs2.readFileSync(loc.absolutePath, "utf-8"));
-      if (existing.mcpServers?.["01software"]) {
-        console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(01software already configured)"));
-        return;
-      }
-      existing.mcpServers = existing.mcpServers || {};
-      existing.mcpServers["01software"] = getMcpServerEntry(apiKey);
-      fs2.writeFileSync(loc.absolutePath, JSON.stringify(existing, null, 2) + "\n");
-      console.log(pc2.green("  Updated"), loc.displayPath);
-    } catch {
-      console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(could not parse existing file)"));
-    }
-  } else {
-    fs2.writeFileSync(loc.absolutePath, getMcpConfigTemplate(apiKey));
+function writeJsonMcp(loc) {
+  if (!fs2.existsSync(loc.absolutePath)) {
+    fs2.writeFileSync(loc.absolutePath, getMcpConfigTemplate(loc.jsonClient));
     console.log(pc2.green("  Created"), loc.displayPath);
+    return;
   }
+  let existing;
+  try {
+    existing = JSON.parse(fs2.readFileSync(loc.absolutePath, "utf-8"));
+  } catch {
+    console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(could not parse existing file)"));
+    return;
+  }
+  const nextEntry = getMcpServerEntry(loc.jsonClient);
+  if (existing.mcpServers?.["01software"] && JSON.stringify(existing.mcpServers["01software"]) === JSON.stringify(nextEntry)) {
+    console.log(pc2.dim("  Unchanged"), loc.displayPath);
+    return;
+  }
+  existing.mcpServers = existing.mcpServers || {};
+  existing.mcpServers["01software"] = nextEntry;
+  fs2.writeFileSync(loc.absolutePath, JSON.stringify(existing, null, 2) + "\n");
+  console.log(pc2.green("  Updated"), loc.displayPath);
 }
-function writeTomlMcp(loc, apiKey) {
-  const section = getCodexMcpTomlSection(apiKey);
-  if (fs2.existsSync(loc.absolutePath)) {
-    const existing = fs2.readFileSync(loc.absolutePath, "utf-8");
-    if (existing.includes(CODEX_MCP_SECTION_MARKER)) {
-      console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(01software already configured)"));
-      return;
-    }
+function writeTomlMcp(loc) {
+  const section = getCodexMcpTomlSection();
+  if (!fs2.existsSync(loc.absolutePath)) {
+    fs2.writeFileSync(loc.absolutePath, section.trimStart());
+    console.log(pc2.green("  Created"), loc.displayPath);
+    return;
+  }
+  const existing = fs2.readFileSync(loc.absolutePath, "utf-8");
+  if (!existing.includes(CODEX_MCP_SECTION_MARKER)) {
     const sep = existing.endsWith("\n") ? "" : "\n";
     fs2.appendFileSync(loc.absolutePath, sep + section);
     console.log(pc2.green("  Updated"), loc.displayPath);
-  } else {
-    fs2.writeFileSync(loc.absolutePath, section.trimStart());
-    console.log(pc2.green("  Created"), loc.displayPath);
+    return;
+  }
+  const replaced = replaceTomlMcpSection(existing, section);
+  if (replaced === existing) {
+    console.log(pc2.dim("  Unchanged"), loc.displayPath);
+    return;
   }
+  fs2.writeFileSync(loc.absolutePath, replaced);
+  console.log(pc2.green("  Updated"), loc.displayPath);
 }
 function addToGitignore(cwd, tools) {
   const entries = [];
@@ -682,7 +869,7 @@ function addToGitignore(cwd, tools) {
   const existing = fs2.existsSync(gitignorePath) ? fs2.readFileSync(gitignorePath, "utf-8") : "";
   const toAdd = entries.filter((e) => !existing.includes(e));
   if (toAdd.length === 0) return;
-  const content = "\n# MCP configs (contain API key)\n" + toAdd.join("\n") + "\n";
+  const content = "\n# MCP configs\n" + toAdd.join("\n") + "\n";
   if (fs2.existsSync(gitignorePath)) {
     fs2.appendFileSync(gitignorePath, content);
   } else {
@@ -690,7 +877,7 @@ function addToGitignore(cwd, tools) {
   }
   console.log(pc2.green("  Updated"), ".gitignore", pc2.dim(`(added ${toAdd.join(", ")})`));
 }
-async function writeClaudeDocs(cwd, publishableKey, secretKey, tenantName) {
+async function writeClaudeDocs(cwd, publishableKey, secretKey, tenantName, policy) {
   let ctx = {
     tenantName: tenantName || "Your Tenant",
     features: void 0,
@@ -727,24 +914,16 @@ async function writeClaudeDocs(cwd, publishableKey, secretKey, tenantName) {
       fs2.appendFileSync(claudeMdPath, prefix + importLine + "\n");
       console.log(pc2.green("  Updated"), ".claude/CLAUDE.md", pc2.dim("(added @import)"));
     } else {
-      console.log(pc2.yellow("  Skipped"), ".claude/CLAUDE.md", pc2.dim("(@import already present)"));
+      console.log(pc2.dim("  Unchanged"), ".claude/CLAUDE.md");
     }
   }
   for (const { dirName, content } of getSkillFiles()) {
     const skillDir = path2.join(skillsDir, dirName);
     const skillPath = path2.join(skillDir, "SKILL.md");
-    if (!fs2.existsSync(skillPath)) {
-      fs2.mkdirSync(skillDir, { recursive: true });
-      fs2.writeFileSync(skillPath, content);
-      console.log(pc2.green("  Created"), `.claude/skills/${dirName}/SKILL.md`);
-    } else {
-      console.log(pc2.yellow("  Skipped"), `.claude/skills/${dirName}/SKILL.md`, pc2.dim("(already exists)"));
-    }
+    fs2.mkdirSync(skillDir, { recursive: true });
+    await writeFileWithPolicy(cwd, skillPath, content, policy);
   }
 }
-function relativePath(cwd, filePath) {
-  return path2.relative(cwd, filePath);
-}
 var WS_FILE = "pnpm-workspace.yaml";
 var WS_BACKUP = "pnpm-workspace.yaml.bak";
 function hasPnpmWorkspace(cwd) {
@@ -854,23 +1033,35 @@ async function main() {
       console.log(pc3.cyan("    import { QueryProvider } from '@/lib/software/query-provider'"));
       console.log(pc3.cyan("    <QueryProvider>{children}</QueryProvider>"));
       console.log();
+      console.log(pc3.dim("  Optional: start browser analytics with the generated helper:"));
+      console.log();
+      console.log(pc3.cyan("    import { analytics } from '@/lib/software/analytics'"));
+      console.log(pc3.cyan("    analytics.track('signup')"));
+      console.log();
     } else if (env === "react-vite" || env === "react-cra") {
       console.log(pc3.dim("  Wrap your app entry with QueryProvider:"));
       console.log();
       console.log(pc3.cyan("    import { QueryProvider } from './lib/software/query-provider'"));
       console.log(pc3.cyan("    <QueryProvider><App /></QueryProvider>"));
       console.log();
+      console.log(pc3.dim("  Optional: start browser analytics with the generated helper:"));
+      console.log();
+      console.log(pc3.cyan("    import { analytics } from './lib/software/analytics'"));
+      console.log(pc3.cyan("    analytics.track('signup')"));
+      console.log();
     } else if (env === "vanilla") {
       console.log(pc3.dim("  Replace YOUR_PUBLISHABLE_KEY in lib/software/client.ts"));
       console.log();
       console.log(pc3.cyan("    import { client } from './lib/software/client'"));
-      console.log(pc3.cyan("    const posts = await client.from('posts').find()"));
+      console.log(pc3.cyan("    const articles = await client.from('articles').find()"));
+      console.log();
+      console.log(pc3.dim("  Optional: wire the analytics helper in lib/software/analytics.ts"));
       console.log();
     } else if (env === "node") {
       console.log(pc3.dim("  Use the server client:"));
       console.log();
       console.log(pc3.cyan("    import { serverClient } from './lib/software/server'"));
-      console.log(pc3.cyan("    const posts = await serverClient.from('posts').find()"));
+      console.log(pc3.cyan("    const articles = await serverClient.from('articles').find()"));
       console.log();
     } else if (env === "edge") {
       console.log(pc3.dim("  Pass your env bindings to createEdgeClient():"));
@@ -882,11 +1073,11 @@ async function main() {
     const missingPublishableKey = env !== "vanilla" && !answers.publishableKey;
     const missingSecretKey = (env === "nextjs" || env === "node") && !answers.secretKey;
     if (missingPublishableKey || missingSecretKey) {
-      console.log(pc3.dim("  Update .env with your API keys"));
+      console.log(pc3.dim("  Update .env with your SDK credentials"));
       console.log();
     }
-    if (answers.aiTools.length > 0 && (!answers.publishableKey || !answers.secretKey)) {
-      console.log(pc3.dim("  Update MCP config x-api-key with your sk01_... token"));
+    if (answers.aiTools.length > 0) {
+      console.log(pc3.dim("  MCP config uses OAuth discovery."));
       console.log();
     }
     if (env !== "vanilla") {