@reddoorla/maintenance 0.88.2 → 0.89.0

package/dist/{chunk-7FFUBF4I.js → chunk-AX22DH6S.js}

@@ -1,6 +1,6 @@
 import {
   REPORT_LIST_COLUMNS
-} from "./chunk-GQDDWYU2.js";
+} from "./chunk-QBAAZY7W.js";
 import {
   mapReportRecord,
   mapWebsiteRecord
@@ -129,4 +129,4 @@ export {
   checkFleetParity,
   formatParityResult
 };
-//# sourceMappingURL=chunk-7FFUBF4I.js.map
+//# sourceMappingURL=chunk-AX22DH6S.js.map

package/dist/{chunk-7TMWBXX7.js → chunk-DXKF552B.js}

@@ -950,6 +950,12 @@ async function analyzeSite(url, crawl, checks, deps = defaultAnalyzeDeps()) {
   return verifyEvidence(parsed, crawl);
 }
 
+// src/prospect/claude-code.ts
+import { spawn } from "child_process";
+import os from "os";
+import { StringDecoder } from "string_decoder";
+import { z as z2 } from "zod";
+
 // src/prospect/probes.ts
 var MAX_QUERIES = 9;
 var SNIPPET_CHARS = 300;
@@ -1115,11 +1121,15 @@ async function runVisibilityProbes(input, engines, opts = {}) {
   const nameIsDistinctive = isDistinctiveName(brand);
   const answers = [];
   const competitorCounts = /* @__PURE__ */ new Map();
+  const perEngine = /* @__PURE__ */ new Map();
   for (const engine of engines) {
+    const tally = { categoryAttempted: 0, answeredAny: false };
+    perEngine.set(engine.name, tally);
     await pacedEach(
       queries,
       delayMs,
       async ({ query, kind }) => {
+        if (kind === "category") tally.categoryAttempted += 1;
         let reply;
         try {
           reply = await engine.ask(query);
@@ -1132,6 +1142,7 @@ async function runVisibilityProbes(input, engines, opts = {}) {
             return;
           }
         }
+        tally.answeredAny = true;
         const citedDomains = reply.citedDomains.map(domainOf);
         const domainCited = citedDomains.some((d) => isSameSite(d, prospect));
         const brandMentioned = mentionsBrand(reply.answer.toLowerCase(), brand);
@@ -1161,13 +1172,15 @@ async function runVisibilityProbes(input, engines, opts = {}) {
   }
   const categoryAnswers = answers.filter((a) => a.kind === "category");
   const visibleCategory = categoryAnswers.filter((a) => a.countedAsVisible).length;
-  const visibilityScore = categoryAnswers.length === 0 ? null : Math.round(visibleCategory / categoryAnswers.length * 100);
+  const categoryAttempted = [...perEngine.values()].filter((t) => t.answeredAny).reduce((n, t) => n + t.categoryAttempted, 0);
+  const visibilityScore = categoryAttempted === 0 || categoryAnswers.length === 0 ? null : Math.round(visibleCategory / categoryAttempted * 100);
   const brandedRecognized = answers.some((a) => a.kind === "branded" && a.domainCited);
   return {
     answers,
     visibilityScore,
     brandedRecognized,
-    competitorsSeen: [...competitorCounts.entries()].map(([domain, count]) => ({ domain, count })).sort((a, b) => b.count - a.count).slice(0, 8)
+    competitorsSeen: [...competitorCounts.entries()].map(([domain, count]) => ({ domain, count })).sort((a, b) => b.count - a.count).slice(0, 8),
+    categoryProbes: { attempted: categoryAttempted, answered: categoryAnswers.length }
   };
 }
 function perplexityEngine(apiKey, fetchImpl = fetch) {
@@ -1233,14 +1246,250 @@ function claudeWebSearchEngine(createMessage) {
     }
   };
 }
-function defaultEngines() {
+function defaultEngines(claude = claudeWebSearchEngine()) {
   const engines = [];
   const key = process.env.PERPLEXITY_API_KEY?.trim();
   if (key) engines.push(perplexityEngine(key));
-  engines.push(claudeWebSearchEngine());
+  engines.push(claude);
   return engines;
 }
 
+// src/prospect/claude-code.ts
+function llmAuthMode(env = process.env) {
+  const raw = (env.PROSPECT_LLM_AUTH ?? "").trim();
+  if (raw === "" || raw === "api") return "api";
+  if (raw === "subscription") return "subscription";
+  throw new Error(`PROSPECT_LLM_AUTH must be "api" or "subscription", got "${raw}"`);
+}
+function childEnv(env = process.env) {
+  const out = { ...env };
+  delete out.ANTHROPIC_API_KEY;
+  delete out.ANTHROPIC_AUTH_TOKEN;
+  delete out.CLAUDE_CODE_USE_BEDROCK;
+  delete out.CLAUDE_CODE_USE_VERTEX;
+  delete out.ANTHROPIC_BASE_URL;
+  if (!out.CLAUDE_CODE_OAUTH_TOKEN && env.CLAUDE_OAUTH) {
+    out.CLAUDE_CODE_OAUTH_TOKEN = env.CLAUDE_OAUTH;
+  }
+  return out;
+}
+var BASE_DISALLOWED = "Bash,Edit,Write,Read,Glob,Grep,Task,TodoWrite,NotebookEdit,WebFetch,Skill,SlashCommand";
+var ANALYZE_DISALLOWED = `${BASE_DISALLOWED},WebSearch`;
+var ISOLATION_ARGS = ["--setting-sources", "project", "--strict-mcp-config"];
+var PROBE_SYSTEM_PROMPT = "You are an answer engine. Answer the user's question directly and concisely, searching the web when it helps.";
+var ANALYZE_TIMEOUT_MS = 10 * 6e4;
+var PROBE_TIMEOUT_MS = 4 * 6e4;
+var MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+function makeClaudeCodeRun(binary = "claude") {
+  return ({ args, stdin, env, timeoutMs }) => new Promise((resolve, reject) => {
+    const child = spawn(binary, args, { env, cwd: os.tmpdir(), stdio: ["pipe", "pipe", "pipe"] });
+    const outDecoder = new StringDecoder("utf8");
+    const errDecoder = new StringDecoder("utf8");
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      child.kill("SIGKILL");
+      reject(new Error(`claude -p timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const guard = () => {
+      if (stdout.length + stderr.length <= MAX_OUTPUT_BYTES) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill("SIGKILL");
+      reject(new Error("claude -p produced more output than any real run should"));
+    };
+    child.stdout.on("data", (d) => {
+      stdout += outDecoder.write(d);
+      guard();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += errDecoder.write(d);
+      guard();
+    });
+    child.stdin.on("error", () => {
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ stdout: stdout + outDecoder.end(), stderr: stderr + errDecoder.end(), code });
+    });
+    child.stdin.end(stdin);
+  });
+}
+var defaultClaudeCodeRun = makeClaudeCodeRun();
+function contentBlocks(ev) {
+  const content = ev.message?.content;
+  if (!Array.isArray(content)) return [];
+  return content.filter((b) => typeof b === "object" && b !== null);
+}
+function analyzeJsonSchema() {
+  const { $schema: _meta, ...schema } = z2.toJSONSchema(AnalyzeSchema);
+  return JSON.stringify(schema);
+}
+function claudeCodeAnalyzeDeps(run = defaultClaudeCodeRun) {
+  return {
+    async run({ system, user }) {
+      const args = [
+        "-p",
+        "--output-format",
+        "json",
+        "--json-schema",
+        analyzeJsonSchema(),
+        "--system-prompt",
+        system,
+        "--model",
+        "claude-opus-5",
+        "--no-session-persistence",
+        "--disallowedTools",
+        ANALYZE_DISALLOWED,
+        ...ISOLATION_ARGS,
+        // Spend bound: a real analyze measured ~$0.20-equivalent; this is a
+        // runaway backstop, not a working ceiling.
+        "--max-budget-usd",
+        "5"
+      ];
+      const res = await run({ args, stdin: user, env: childEnv(), timeoutMs: ANALYZE_TIMEOUT_MS });
+      if (res.code !== 0) {
+        throw new Error(`claude -p (analyze) exited ${res.code}: ${res.stderr.slice(0, 400)}`);
+      }
+      let envelope;
+      try {
+        envelope = JSON.parse(res.stdout);
+      } catch {
+        throw new Error(
+          `claude -p (analyze) printed something other than the JSON envelope: ${res.stdout.slice(0, 200)}`
+        );
+      }
+      if (envelope.is_error || envelope.subtype !== "success") {
+        throw new Error(
+          `claude -p (analyze) failed (${envelope.subtype ?? "unknown"}): ${String(envelope.result ?? "").slice(0, 400)}`
+        );
+      }
+      if (envelope.structured_output === void 0) {
+        throw new Error("claude -p (analyze) returned no structured_output");
+      }
+      return envelope.structured_output;
+    }
+  };
+}
+function extractLinksArray(text) {
+  const at = text.indexOf("Links:");
+  if (at < 0) return null;
+  const start = text.indexOf("[", at);
+  if (start < 0) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "[") depth++;
+    else if (ch === "]" && --depth === 0) {
+      try {
+        const parsed = JSON.parse(text.slice(start, i + 1));
+        return Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function urlsFromSearchResult(text) {
+  const links = extractLinksArray(text);
+  if (links) {
+    return links.map((l) => l.url).filter((u) => typeof u === "string");
+  }
+  return [...text.matchAll(/https?:\/\/[^\s"'<>\])]+/g)].map((m) => m[0]);
+}
+function claudeCodeEngine(run = defaultClaudeCodeRun) {
+  return {
+    name: "claude-code",
+    async ask(query) {
+      const args = [
+        "-p",
+        // stream-json is refused in print mode without --verbose.
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--allowedTools",
+        "WebSearch",
+        "--disallowedTools",
+        BASE_DISALLOWED,
+        "--model",
+        PROBE_MODEL,
+        "--no-session-persistence",
+        "--system-prompt",
+        PROBE_SYSTEM_PROMPT,
+        ...ISOLATION_ARGS,
+        // The API engine bounds its loop (4 turns, 4 searches); the CLI has no
+        // turn flag on this build, so bound by computed spend instead — a real
+        // probe measured ~$0.40-equivalent.
+        "--max-budget-usd",
+        "2"
+      ];
+      const res = await run({ args, stdin: query, env: childEnv(), timeoutMs: PROBE_TIMEOUT_MS });
+      if (res.code !== 0) {
+        throw new Error(`claude -p (probe) exited ${res.code}: ${res.stderr.slice(0, 400)}`);
+      }
+      const events = res.stdout.split("\n").filter(Boolean).flatMap((line) => {
+        try {
+          return [JSON.parse(line)];
+        } catch {
+          return [];
+        }
+      });
+      const searchIds = /* @__PURE__ */ new Set();
+      for (const ev of events) {
+        if (ev.type !== "assistant") continue;
+        for (const block of contentBlocks(ev)) {
+          if (block.type === "tool_use" && block.name === "WebSearch") searchIds.add(block.id);
+        }
+      }
+      const citedDomains = [];
+      for (const ev of events) {
+        if (ev.type !== "user") continue;
+        for (const block of contentBlocks(ev)) {
+          if (block.type !== "tool_result" || typeof block.content !== "string") continue;
+          if (!searchIds.has(block.tool_use_id) || block.is_error === true) continue;
+          citedDomains.push(...urlsFromSearchResult(block.content).map(domainOf));
+        }
+      }
+      const result = events.find((ev) => ev.type === "result");
+      if (!result) {
+        throw new Error("claude -p (probe) produced no result event");
+      }
+      if (result.is_error || result.subtype !== "success") {
+        throw new Error(
+          `claude -p (probe) failed (${result.subtype ?? "unknown"}): ${String(result.result ?? "").slice(0, 400)}`
+        );
+      }
+      return { answer: typeof result.result === "string" ? result.result : "", citedDomains };
+    }
+  };
+}
+
 // src/prospect/lighthouse.ts
 function defaultLighthouseDeps() {
   return {
@@ -1275,6 +1524,15 @@ async function runLighthouse(url, deps = defaultLighthouseDeps()) {
 }
 
 // src/prospect/pipeline.ts
+function envAnalyzeDeps(factories = {
+  api: defaultAnalyzeDeps,
+  subscription: claudeCodeAnalyzeDeps
+}) {
+  return llmAuthMode() === "subscription" ? factories.subscription() : factories.api();
+}
+function envEngines() {
+  return llmAuthMode() === "subscription" ? defaultEngines(claudeCodeEngine()) : defaultEngines();
+}
 var PROBES_SKIPPED = "skipped (--no-probes)";
 var ANALYZE_SKIPPED = "skipped \u2014 the checks stage failed";
 async function stage(name, deps, fn) {
@@ -1290,6 +1548,7 @@ async function stage(name, deps, fn) {
   }
 }
 async function runProspectAudit(url, opts, deps = {}) {
+  const llmAuth = llmAuthMode();
   const crawlDeps = deps.crawl ?? defaultCrawlDeps();
   deps.onStage?.("crawl", "start");
   let crawlData;
@@ -1315,7 +1574,7 @@ async function runProspectAudit(url, opts, deps = {}) {
   const analyze = checks.ok ? await stage(
     "analyze",
     deps,
-    async () => analyzeSite(url, crawlData, checks.data, deps.analyze ?? defaultAnalyzeDeps())
+    async () => analyzeSite(url, crawlData, checks.data, deps.analyze ?? envAnalyzeDeps())
   ) : { ok: false, error: ANALYZE_SKIPPED };
   const businessName = opts.business?.trim() || (analyze.ok ? analyze.data.businessName : "") || null;
   const probeOpts = {
@@ -1336,7 +1595,7 @@ async function runProspectAudit(url, opts, deps = {}) {
           categoryQueries: analyze.ok ? analyze.data.categoryQueries : [],
           competitors: opts.competitors ?? []
         },
-        deps.engines ?? defaultEngines(),
+        deps.engines ?? envEngines(),
         probeOpts
       )
     );
@@ -1344,6 +1603,7 @@ async function runProspectAudit(url, opts, deps = {}) {
   return {
     url,
     businessName,
+    llmAuth,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     scores: computeScores({
       checks: checks.ok ? checks.data : null,
@@ -1361,8 +1621,10 @@ async function runProspectAudit(url, opts, deps = {}) {
 
 export {
   resolveBusinessName,
+  envAnalyzeDeps,
+  envEngines,
   PROBES_SKIPPED,
   ANALYZE_SKIPPED,
   runProspectAudit
 };
-//# sourceMappingURL=chunk-7TMWBXX7.js.map
+//# sourceMappingURL=chunk-DXKF552B.js.map