@insforge/cli 0.1.47 → 0.1.49

package/dist/index.js

@@ -5,7 +5,7 @@ import { readFileSync as readFileSync7 } from "fs";
 import { join as join9, dirname } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
-import * as clack14 from "@clack/prompts";
+import * as clack15 from "@clack/prompts";
 
 // src/lib/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
@@ -16,6 +16,8 @@ var CREDENTIALS_FILE = join(GLOBAL_DIR, "credentials.json");
 var CONFIG_FILE = join(GLOBAL_DIR, "config.json");
 var DEFAULT_PLATFORM_URL = "https://api.insforge.dev";
 var DEFAULT_FRONTEND_URL = "https://insforge.dev";
+var FAKE_PROJECT_ID = "fa4e0000-1234-5678-90ab-cd1234567890";
+var FAKE_ORG_ID = "fa4e0001-1234-5678-90ab-cd1234567890";
 function ensureGlobalDir() {
   if (!existsSync(GLOBAL_DIR)) {
     mkdirSync(GLOBAL_DIR, { recursive: true });
@@ -365,7 +367,7 @@ ${authUrl}`);
 import * as clack2 from "@clack/prompts";
 async function requireAuth(apiUrl, allowOssBypass = true) {
   const projConfig = getProjectConfig();
-  if (allowOssBypass && projConfig?.project_id === "oss-project") {
+  if (allowOssBypass && projConfig?.project_id === FAKE_PROJECT_ID) {
     return {
       access_token: "oss-token",
       refresh_token: "oss-refresh",
@@ -440,6 +442,13 @@ async function platformFetch(path5, options = {}, apiUrl) {
     ...options.headers ?? {}
   };
   const fullUrl = `${baseUrl}${path5}`;
+  if (process.env.INSFORGE_DEBUG) {
+    console.error(`[DEBUG] ${options.method ?? "GET"} ${fullUrl}`);
+    console.error(`[DEBUG] Headers: ${JSON.stringify(headers, null, 2)}`);
+    if (options.body) {
+      console.error(`[DEBUG] Body: ${typeof options.body === "string" ? options.body : JSON.stringify(options.body)}`);
+    }
+  }
   let res;
   try {
     res = await fetch(fullUrl, { ...options, headers });
@@ -463,7 +472,8 @@ async function platformFetch(path5, options = {}, apiUrl) {
   }
   if (!res.ok) {
     const err = await res.json().catch(() => ({}));
-    throw new CLIError(err.error ?? `Request failed: ${res.status}`, res.status === 403 ? 5 : 1);
+    const msg = err.message ? `${err.error ?? res.status}: ${err.message}` : err.error ?? `Request failed: ${res.status}`;
+    throw new CLIError(msg, res.status === 403 ? 5 : 1);
   }
   return res;
 }
@@ -527,6 +537,56 @@ async function reportAgentConnected(payload, apiUrl) {
     body: JSON.stringify(payload)
   });
 }
+async function streamDiagnosticAnalysis(payload, onEvent, apiUrl) {
+  const res = await platformFetch("/diagnostic/v1/analyze", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  }, apiUrl);
+  const body = res.body;
+  if (!body) throw new CLIError("No response body from diagnostic API.");
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "delta";
+  const VALID_EVENTS = /* @__PURE__ */ new Set(["delta", "tool_call", "tool_result", "done", "error"]);
+  const processLine = (line) => {
+    if (line.startsWith("event:")) {
+      const evt = line.slice(6).trim();
+      currentEvent = VALID_EVENTS.has(evt) ? evt : null;
+    } else if (line.startsWith("data:")) {
+      if (!currentEvent) return;
+      const raw = line.slice(5).trim();
+      if (!raw) return;
+      try {
+        const data = JSON.parse(raw);
+        onEvent({ type: currentEvent, data });
+      } catch {
+      }
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      processLine(line);
+    }
+  }
+  buffer += decoder.decode();
+  if (buffer.trim()) {
+    processLine(buffer);
+  }
+}
+async function rateDiagnosticSession(sessionId, rating, comment, apiUrl) {
+  const body = { rating };
+  if (comment) body.comment = comment;
+  await platformFetch(`/diagnostic/v1/sessions/${sessionId}/rating`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  }, apiUrl);
+}
 async function createProject(orgId, name, region, apiUrl) {
   const body = { name };
   if (region) body.region = region;
@@ -757,6 +817,7 @@ import { promisify as promisify3 } from "util";
 import * as fs4 from "fs/promises";
 import * as path4 from "path";
 import * as clack8 from "@clack/prompts";
+import pc from "picocolors";
 
 // src/lib/skills.ts
 import { exec } from "child_process";
@@ -918,7 +979,7 @@ function trackDiagnose(subcommand, config) {
     project_name: config.project_name,
     org_id: config.org_id,
     region: config.region,
-    oss_mode: config.project_id === "oss-project"
+    oss_mode: config.project_id === FAKE_PROJECT_ID
   });
 }
 async function shutdownAnalytics() {
@@ -1719,11 +1780,11 @@ function registerProjectLinkCommand(program2) {
             throw new CLIError("Invalid --api-base-url. Please provide a valid URL.");
           }
           const projectConfig2 = {
-            project_id: "oss-project",
+            project_id: FAKE_PROJECT_ID,
             project_name: "oss-project",
-            org_id: "oss-org",
-            appkey: "oss",
-            region: "local",
+            org_id: FAKE_ORG_ID,
+            appkey: "ossfkey",
+            region: "us-test",
             api_key: opts.apiKey,
             oss_host: opts.apiBaseUrl.replace(/\/$/, "")
             // remove trailing slash if any
@@ -1893,11 +1954,14 @@ function registerProjectLinkCommand(program2) {
         await reportCliUsage("cli.link", true, 6, projectConfig);
         if (!json) {
           const dashboardUrl = `${getFrontendUrl()}/dashboard/project/${project.id}`;
-          clack8.log.step(`Dashboard: ${dashboardUrl}`);
+          clack8.log.step(`Dashboard: ${pc.underline(dashboardUrl)}`);
           if (templateDownloaded) {
-            const steps = [`cd ${dirName}`, "npm run dev"];
-            clack8.note(steps.join("\n"), "Next steps");
-            clack8.note("Open your coding agent (Claude Code, Codex, Cursor, etc.) to add new features.", "Keep building");
+            const runCommand = `${pc.cyan("cd")} ${pc.green(dirName)} ${pc.dim("&&")} ${pc.cyan("npm run dev")}`;
+            const steps = [
+              `${pc.bold("1.")} ${runCommand}`,
+              `${pc.bold("2.")} Open ${pc.cyan("Claude Code")} or ${pc.cyan("Cursor")} and prompt your agent to add more features`
+            ];
+            clack8.note(steps.join("\n"), "What's next");
           } else {
             clack8.log.warn("Template download failed. You can retry or set up manually.");
           }
@@ -4113,6 +4177,10 @@ function formatSize2(gb) {
   return `${gb.toFixed(2)} GB`;
 }
 
+// src/commands/diagnose/index.ts
+import * as os from "os";
+import * as clack14 from "@clack/prompts";
+
 // src/commands/diagnose/metrics.ts
 var METRIC_LABELS = {
   cpu_usage: "CPU Usage",
@@ -4179,7 +4247,7 @@ function registerDiagnoseMetricsCommand(diagnoseCmd2) {
       await requireAuth(apiUrl);
       const config = getProjectConfig();
       if (!config) throw new ProjectNotLinkedError();
-      if (config.project_id === "oss-project") {
+      if (config.project_id === FAKE_PROJECT_ID) {
         throw new CLIError(
           "Metrics requires InsForge Platform login. Not available when linked via --api-key."
         );
@@ -4243,7 +4311,7 @@ function registerDiagnoseAdvisorCommand(diagnoseCmd2) {
       await requireAuth(apiUrl);
       const config = getProjectConfig();
       if (!config) throw new ProjectNotLinkedError();
-      if (config.project_id === "oss-project") {
+      if (config.project_id === FAKE_PROJECT_ID) {
         throw new CLIError(
           "Advisor requires InsForge Platform login. Not available when linked via --api-key."
         );
@@ -4581,82 +4649,234 @@ function registerDiagnoseLogsCommand(diagnoseCmd2) {
 function sectionHeader(title) {
   return `\u2500\u2500 ${title} ${"\u2500".repeat(Math.max(0, 44 - title.length))}`;
 }
+async function collectDiagnosticData(projectId, ossMode, apiUrl) {
+  const metricsPromise = ossMode ? Promise.reject(new Error("Platform login required (linked via --api-key)")) : fetchMetricsSummary(projectId, apiUrl);
+  const advisorPromise = ossMode ? Promise.reject(new Error("Platform login required (linked via --api-key)")) : fetchAdvisorSummary(projectId, apiUrl);
+  const [metricsResult, advisorResult, dbResult, logsResult] = await Promise.allSettled([
+    metricsPromise,
+    advisorPromise,
+    runDbChecks(),
+    fetchLogsSummary(100)
+  ]);
+  const errors = [];
+  let metrics = null;
+  let advisor = null;
+  let db = null;
+  let logs = null;
+  if (metricsResult.status === "fulfilled") {
+    const data = metricsResult.value;
+    metrics = data.metrics.filter((m) => m.data.length > 0).map((m) => {
+      let sum = 0;
+      let max = -Infinity;
+      for (const d of m.data) {
+        sum += d.value;
+        if (d.value > max) max = d.value;
+      }
+      return {
+        metric: m.metric,
+        latest: m.data[m.data.length - 1].value,
+        avg: sum / m.data.length,
+        max
+      };
+    });
+  } else {
+    errors.push(metricsResult.reason?.message ?? "Metrics unavailable");
+  }
+  if (advisorResult.status === "fulfilled") {
+    advisor = advisorResult.value;
+  } else {
+    errors.push(advisorResult.reason?.message ?? "Advisor unavailable");
+  }
+  if (dbResult.status === "fulfilled") {
+    db = dbResult.value;
+  } else {
+    errors.push(dbResult.reason?.message ?? "DB checks unavailable");
+  }
+  if (logsResult.status === "fulfilled") {
+    logs = logsResult.value;
+  } else {
+    errors.push(logsResult.reason?.message ?? "Logs unavailable");
+  }
+  return { metrics, advisor, db, logs, errors };
+}
 function registerDiagnoseCommands(diagnoseCmd2) {
-  diagnoseCmd2.description("Backend diagnostics \u2014 run with no subcommand for a full health report").action(async (_opts, cmd) => {
+  diagnoseCmd2.description("Backend diagnostics \u2014 run with no subcommand for a full health report").option("--ai <question>", "Ask AI to analyze your diagnostic data (1-2000 chars)").action(async (opts, cmd) => {
     const { json, apiUrl } = getRootOpts(cmd);
+    const usageEvent = opts.ai ? "cli.diagnose.ai" : "cli.diagnose";
     try {
       await requireAuth(apiUrl);
       const config = getProjectConfig();
       if (!config) throw new ProjectNotLinkedError();
       const projectId = config.project_id;
       const projectName = config.project_name;
-      const ossMode = config.project_id === "oss-project";
-      trackDiagnose("report", config);
-      const metricsPromise = ossMode ? Promise.reject(new Error("Platform login required (linked via --api-key)")) : fetchMetricsSummary(projectId, apiUrl);
-      const advisorPromise = ossMode ? Promise.reject(new Error("Platform login required (linked via --api-key)")) : fetchAdvisorSummary(projectId, apiUrl);
-      const [metricsResult, advisorResult, dbResult, logsResult] = await Promise.allSettled([
-        metricsPromise,
-        advisorPromise,
-        runDbChecks(),
-        fetchLogsSummary(100)
-      ]);
-      if (json) {
-        const report = { project: projectName, errors: [] };
-        const errors = [];
-        if (metricsResult.status === "fulfilled") {
-          const data = metricsResult.value;
-          report.metrics = data.metrics.map((m) => {
-            if (m.data.length === 0) return { metric: m.metric, latest: null, avg: null, max: null };
-            let sum = 0;
-            let max = -Infinity;
-            for (const d of m.data) {
-              sum += d.value;
-              if (d.value > max) max = d.value;
-            }
-            return {
-              metric: m.metric,
-              latest: m.data[m.data.length - 1].value,
-              avg: sum / m.data.length,
-              max
+      const ossMode = config.project_id === FAKE_PROJECT_ID;
+      trackDiagnose(opts.ai ? "ai" : "report", config);
+      if (opts.ai) {
+        const question = String(opts.ai).trim();
+        if (question.length === 0 || question.length > 2e3) {
+          throw new CLIError("Question must be between 1 and 2000 characters.");
+        }
+        const s = !json ? clack14.spinner() : null;
+        s?.start("Collecting diagnostic data...");
+        const data2 = await collectDiagnosticData(projectId, ossMode, apiUrl);
+        const cliVersion = "0.1.49";
+        s?.stop("Data collected");
+        if (!json) {
+          console.log(`
+  AI Diagnosis \u2014 ${projectName}
+`);
+          console.log(sectionHeader("Question"));
+          console.log(`  ${question}
+`);
+          console.log(sectionHeader("Analysis"));
+        }
+        let sessionId;
+        let fullText = "";
+        const jsonEvents = [];
+        let streamError;
+        const context = {
+          context_version: "diagnostic-v1",
+          client_info: {
+            cli_version: cliVersion,
+            node_version: process.version,
+            os: `${os.platform()} ${os.release()}`
+          }
+        };
+        if (Array.isArray(data2.metrics) && data2.metrics.length > 0) {
+          context.metrics = data2.metrics;
+        }
+        if (data2.advisor) {
+          const adv = data2.advisor;
+          const summary = adv.summary;
+          const rawErrors = adv.collectorErrors;
+          if (summary) {
+            context.advisor = {
+              summary: {
+                total: summary.total ?? 0,
+                critical: summary.critical ?? 0,
+                warning: summary.warning ?? 0,
+                info: summary.info ?? 0
+              },
+              collectorErrors: rawErrors?.map(
+                (e) => typeof e === "string" ? e : JSON.stringify(e)
+              ) ?? []
             };
-          });
-        } else {
-          report.metrics = null;
-          errors.push(metricsResult.reason?.message ?? "Metrics unavailable");
+          }
         }
-        if (advisorResult.status === "fulfilled") {
-          report.advisor = advisorResult.value;
-        } else {
-          report.advisor = null;
-          errors.push(advisorResult.reason?.message ?? "Advisor unavailable");
+        if (data2.db) {
+          const rawDb = data2.db;
+          const safeDb = {};
+          for (const [key, rows] of Object.entries(rawDb)) {
+            safeDb[key] = rows.map((row) => {
+              const out = {};
+              for (const [k, v] of Object.entries(row)) {
+                out[k] = v === null || v === void 0 ? "" : String(v);
+              }
+              return out;
+            });
+          }
+          if (Object.keys(safeDb).length > 0) {
+            context.db = safeDb;
+          }
         }
-        if (dbResult.status === "fulfilled") {
-          report.db = dbResult.value;
-        } else {
-          report.db = null;
-          errors.push(dbResult.reason?.message ?? "DB checks unavailable");
+        if (Array.isArray(data2.logs) && data2.logs.length > 0) {
+          context.logs = data2.logs.map((s2) => ({
+            source: s2.source,
+            total: s2.total,
+            errors: s2.errors.map((e) => ({
+              timestamp: e.timestamp ?? "",
+              message: e.message ?? "",
+              source: e.source ?? ""
+            }))
+          }));
         }
-        if (logsResult.status === "fulfilled") {
-          report.logs = logsResult.value;
-        } else {
-          report.logs = null;
-          errors.push(logsResult.reason?.message ?? "Logs unavailable");
+        await streamDiagnosticAnalysis({
+          project_id: projectId,
+          question,
+          context
+        }, (event) => {
+          if (event.type === "done") {
+            sessionId = event.data.session_id;
+          }
+          if (event.type === "error") {
+            streamError = new CLIError(String(event.data.message ?? "Unknown diagnostic error"));
+          }
+          if (json) {
+            jsonEvents.push({ type: event.type, ...event.data });
+            return;
+          }
+          switch (event.type) {
+            case "delta":
+              process.stdout.write(String(event.data.text ?? ""));
+              fullText += String(event.data.text ?? "");
+              break;
+            case "tool_call":
+              console.log(`
+  [calling ${event.data.tool_name}...]`);
+              break;
+            case "tool_result":
+              break;
+            case "done":
+              break;
+            case "error":
+              console.error(`
+  Error: ${streamError?.message ?? "Unknown error"}`);
+              break;
+          }
+        }, apiUrl);
+        if (streamError) {
+          throw streamError;
+        }
+        if (!json) {
+          if (fullText && !fullText.endsWith("\n")) console.log("");
+          console.log("");
+        }
+        if (json) {
+          outputJson({ sessionId, events: jsonEvents });
         }
-        report.errors = errors;
-        outputJson(report);
+        if (!json && sessionId) {
+          const ratingChoice = await clack14.select({
+            message: "Was this analysis helpful?",
+            options: [
+              { value: "skip", label: "Skip", hint: "no rating" },
+              { value: "helpful", label: "Helpful", hint: "solved or pointed in right direction" },
+              { value: "not_helpful", label: "Not helpful", hint: "didn't apply to the problem" },
+              { value: "incorrect", label: "Incorrect", hint: "diagnosis was wrong or misleading" }
+            ]
+          });
+          if (!clack14.isCancel(ratingChoice) && ratingChoice !== "skip") {
+            try {
+              await rateDiagnosticSession(
+                sessionId,
+                ratingChoice,
+                void 0,
+                apiUrl
+              );
+              clack14.log.success("Thanks for your feedback!");
+            } catch {
+              clack14.log.warn("Failed to submit rating.");
+            }
+          }
+        }
+        await reportCliUsage(usageEvent, true);
+        return;
+      }
+      const data = await collectDiagnosticData(projectId, ossMode, apiUrl);
+      if (json) {
+        outputJson({ project: projectName, ...data });
       } else {
         console.log(`
   InsForge Health Report \u2014 ${projectName}
 `);
         console.log(sectionHeader("System Metrics (last 1h)"));
-        if (metricsResult.status === "fulfilled") {
-          const metrics = metricsResult.value.metrics;
-          if (metrics.length === 0) {
+        if (data.metrics) {
+          const metricsArr = data.metrics;
+          if (metricsArr.length === 0) {
             console.log("  No metrics data available.");
           } else {
             const vals = {};
-            for (const m of metrics) {
-              if (m.data.length > 0) vals[m.metric] = m.data[m.data.length - 1].value;
+            for (const m of metricsArr) {
+              vals[m.metric] = m.latest;
             }
             const cpu = vals.cpu_usage !== void 0 ? `${vals.cpu_usage.toFixed(1)}%` : "N/A";
             const mem = vals.memory_usage !== void 0 ? `${vals.memory_usage.toFixed(1)}%` : "N/A";
@@ -4667,20 +4887,19 @@ function registerDiagnoseCommands(diagnoseCmd2) {
             console.log(`  Disk: ${disk}  Network: \u2193${netIn} \u2191${netOut}`);
           }
         } else {
-          console.log(`  N/A \u2014 ${metricsResult.reason?.message ?? "unavailable"}`);
+          console.log(`  N/A \u2014 ${data.errors.find((e) => e.includes("Metrics") || e.includes("Platform")) ?? "unavailable"}`);
         }
         console.log("\n" + sectionHeader("Advisor Scan"));
-        if (advisorResult.status === "fulfilled") {
-          const scan = advisorResult.value;
-          const s = scan.summary;
+        if (data.advisor) {
+          const scan = data.advisor;
           const date = new Date(scan.scannedAt).toLocaleDateString();
-          console.log(`  ${date} (${scan.status}) \u2014 ${s.critical} critical \xB7 ${s.warning} warning \xB7 ${s.info} info`);
+          console.log(`  ${date} (${scan.status}) \u2014 ${scan.summary.critical} critical \xB7 ${scan.summary.warning} warning \xB7 ${scan.summary.info} info`);
         } else {
-          console.log(`  N/A \u2014 ${advisorResult.reason?.message ?? "unavailable"}`);
+          console.log(`  N/A \u2014 ${data.errors.find((e) => e.includes("Advisor") || e.includes("Platform")) ?? "unavailable"}`);
         }
         console.log("\n" + sectionHeader("Database"));
-        if (dbResult.status === "fulfilled") {
-          const db = dbResult.value;
+        if (data.db) {
+          const db = data.db;
           const conn = db.connections?.[0];
           const cache = db["cache-hit"]?.[0];
           const deadTuples = (db.bloat ?? []).reduce(
@@ -4695,21 +4914,21 @@ function registerDiagnoseCommands(diagnoseCmd2) {
             `  Dead tuples: ${deadTuples.toLocaleString()}   Locks waiting: ${lockCount}`
           );
         } else {
-          console.log(`  N/A \u2014 ${dbResult.reason?.message ?? "unavailable"}`);
+          console.log(`  N/A \u2014 ${data.errors.find((e) => e.includes("DB")) ?? "unavailable"}`);
         }
         console.log("\n" + sectionHeader("Recent Errors (last 100 logs/source)"));
-        if (logsResult.status === "fulfilled") {
-          const summaries = logsResult.value;
+        if (data.logs) {
+          const summaries = data.logs;
           const parts = summaries.map((s) => `${s.source}: ${s.errors.length}`);
           console.log(`  ${parts.join("  ")}`);
         } else {
-          console.log(`  N/A \u2014 ${logsResult.reason?.message ?? "unavailable"}`);
+          console.log(`  N/A \u2014 ${data.errors.find((e) => e.includes("Logs")) ?? "unavailable"}`);
         }
         console.log("");
       }
-      await reportCliUsage("cli.diagnose", true);
+      await reportCliUsage(usageEvent, true);
     } catch (err) {
-      await reportCliUsage("cli.diagnose", false);
+      await reportCliUsage(usageEvent, false);
       handleError(err, json);
     } finally {
       await shutdownAnalytics();
@@ -4830,7 +5049,7 @@ async function showInteractiveMenu() {
   } catch {
   }
   console.log(INSFORGE_LOGO);
-  clack14.intro(`InsForge CLI v${pkg.version}`);
+  clack15.intro(`InsForge CLI v${pkg.version}`);
   const options = [];
   if (!isLoggedIn) {
     options.push({ value: "login", label: "Log in to InsForge" });
@@ -4846,12 +5065,12 @@ async function showInteractiveMenu() {
     { value: "docs", label: "View documentation" },
     { value: "help", label: "Show all commands" }
   );
-  const action = await clack14.select({
+  const action = await clack15.select({
     message: "What would you like to do?",
     options
   });
-  if (clack14.isCancel(action)) {
-    clack14.cancel("Bye!");
+  if (clack15.isCancel(action)) {
+    clack15.cancel("Bye!");
     process.exit(0);
   }
   switch (action) {