mcp-scraper 0.2.8 → 0.2.9

package/dist/chunk-L6IS63WS.js

@@ -0,0 +1,869 @@
+// src/workflows/artifact-writer.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { dirname, join } from "path";
+import { execFile } from "child_process";
+
+// src/directory/csv.ts
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (quoted) {
+      if (ch === '"' && next === '"') {
+        field += '"';
+        i += 1;
+      } else if (ch === '"') {
+        quoted = false;
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      quoted = true;
+    } else if (ch === ",") {
+      row.push(field);
+      field = "";
+    } else if (ch === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else if (ch !== "\r") {
+      field += ch;
+    }
+  }
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function csvRecords(text) {
+  const rows = parseCsv(text).filter((row) => row.some((cell) => cell.trim() !== ""));
+  const header = rows[0]?.map((cell) => cell.trim()) ?? [];
+  return rows.slice(1).map((row) => {
+    const record = {};
+    for (let i = 0; i < header.length; i += 1) {
+      record[header[i]] = row[i] ?? "";
+    }
+    return record;
+  });
+}
+function csvCell(value) {
+  if (value === null || value === void 0) return "";
+  const text = String(value);
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function rowsToCsv(headers, rows) {
+  return [
+    headers.join(","),
+    ...rows.map((row) => headers.map((header) => csvCell(row[header])).join(","))
+  ].join("\n") + "\n";
+}
+
+// src/lib/slugify.ts
+function slugify(s) {
+  return s.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+
+// src/workflows/artifact-writer.ts
+function workflowOutputBaseDir(outputDir) {
+  return outputDir?.trim() || process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join(homedir(), "Downloads", "mcp-scraper");
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function safeSlug(value) {
+  return slugify(value).replace(/^-+|-+$/g, "").slice(0, 80) || "run";
+}
+var ArtifactWriter = class _ArtifactWriter {
+  constructor(workflowId, title, runId, baseDir, runDir, startedAt, input) {
+    this.workflowId = workflowId;
+    this.title = title;
+    this.runId = runId;
+    this.baseDir = baseDir;
+    this.runDir = runDir;
+    this.startedAt = startedAt;
+    this.input = input;
+  }
+  workflowId;
+  title;
+  runId;
+  baseDir;
+  runDir;
+  startedAt;
+  input;
+  artifacts = [];
+  static async create(workflowId, title, input, outputDir, forcedRunId) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const runId = forcedRunId?.trim() || `${timestamp()}-${safeSlug(workflowId)}-${Math.random().toString(36).slice(2, 8)}`;
+    const nameSource = String(input.keyword ?? input.query ?? input.domain ?? input.state ?? workflowId);
+    const baseDir = workflowOutputBaseDir(outputDir);
+    const runDir = join(baseDir, "workflows", workflowId, `${timestamp()}-${safeSlug(nameSource)}-${safeSlug(runId).slice(0, 20)}`);
+    await mkdir(runDir, { recursive: true });
+    return new _ArtifactWriter(workflowId, title, runId, baseDir, runDir, startedAt, input);
+  }
+  async remember(kind, label, path, rows) {
+    const size = await stat(path).then((s) => s.size).catch(() => void 0);
+    this.artifacts.push({ kind, label, path, bytes: size, rows });
+    return path;
+  }
+  async writeJson(label, relativePath, data) {
+    const path = join(this.runDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(data, null, 2), "utf8");
+    return this.remember("json", label, path);
+  }
+  async writeText(label, relativePath, text, kind = "markdown") {
+    const path = join(this.runDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text, "utf8");
+    return this.remember(kind, label, path);
+  }
+  async writeCsv(label, relativePath, headers, rows) {
+    const path = join(this.runDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, rowsToCsv(headers, rows), "utf8");
+    return this.remember("csv", label, path, rows.length);
+  }
+  async writeHtml(label, relativePath, html) {
+    return this.writeText(label, relativePath, html, "html_report");
+  }
+  async writeManifest(status, counts, warnings, errors) {
+    const manifest = {
+      workflow: this.workflowId,
+      title: this.title,
+      runId: this.runId,
+      status,
+      startedAt: this.startedAt,
+      completedAt: status === "running" ? null : (/* @__PURE__ */ new Date()).toISOString(),
+      input: this.input,
+      artifacts: this.artifacts,
+      warnings,
+      errors,
+      counts
+    };
+    const path = join(this.runDir, "manifest.json");
+    await writeFile(path, JSON.stringify(manifest, null, 2), "utf8");
+    await updateWorkflowIndex(manifest, path, this.baseDir);
+    return path;
+  }
+};
+function indexPath(baseDir = workflowOutputBaseDir()) {
+  return join(baseDir, "workflows", "index.json");
+}
+async function readIndex(baseDir) {
+  const path = indexPath(baseDir);
+  if (!existsSync(path)) return { runs: [] };
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return { runs: [] };
+  }
+}
+async function updateWorkflowIndex(manifest, manifestPath, baseDir) {
+  if (manifest.status === "running") return;
+  const path = indexPath(baseDir);
+  const index = await readIndex(baseDir);
+  const report = manifest.artifacts.find((a) => a.kind === "html_report")?.path ?? null;
+  const entry = {
+    workflow: manifest.workflow,
+    runId: manifest.runId,
+    status: manifest.status,
+    startedAt: manifest.startedAt,
+    reportPath: report,
+    manifestPath,
+    summary: `${manifest.title} (${manifest.status})`
+  };
+  index.runs = [entry, ...index.runs.filter((r) => r.runId !== manifest.runId)].slice(0, 200);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(index, null, 2), "utf8");
+}
+async function listWorkflowReports(outputDir) {
+  return (await readIndex(workflowOutputBaseDir(outputDir))).runs;
+}
+async function findWorkflowReport(id, outputDir) {
+  const runs = await listWorkflowReports(outputDir);
+  if (id === "last") return runs[0] ?? null;
+  return runs.find((run) => run.runId === id) ?? null;
+}
+async function openWorkflowReport(id, outputDir) {
+  const run = await findWorkflowReport(id, outputDir);
+  if (!run?.reportPath) throw new Error(`No report found for "${id}"`);
+  if (platform() === "darwin") {
+    await new Promise((resolve, reject) => {
+      execFile("open", [run.reportPath], (err) => err ? reject(err) : resolve());
+    });
+  }
+  return run.reportPath;
+}
+
+// src/workflows/registry.ts
+import { z as z4 } from "zod";
+
+// src/workflows/http-client.ts
+var WorkflowHttpClient = class {
+  constructor(apiUrl, apiKey, fetchImpl = fetch) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+    this.fetchImpl = fetchImpl;
+  }
+  apiUrl;
+  apiKey;
+  fetchImpl;
+  async post(path, body, timeoutMs = 18e4) {
+    const res = await this.fetchImpl(`${this.apiUrl.replace(/\/$/, "")}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      const message = typeof data.error === "string" ? data.error : `Workflow API ${path} failed with ${res.status}`;
+      throw new Error(message);
+    }
+    return data;
+  }
+};
+
+// src/workflows/workflows/agent-packet.ts
+import { z } from "zod";
+
+// src/workflows/report-renderer.ts
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderTable(table) {
+  const rows = table.rows.map((row) => `<tr>${table.columns.map((col) => `<td>${escapeHtml(row[col])}</td>`).join("")}</tr>`).join("\n");
+  return [
+    `<section>`,
+    `<h2>${escapeHtml(table.title)}</h2>`,
+    `<div class="table-wrap"><table>`,
+    `<thead><tr>${table.columns.map((col) => `<th>${escapeHtml(col)}</th>`).join("")}</tr></thead>`,
+    `<tbody>${rows || `<tr><td colspan="${table.columns.length}">No rows</td></tr>`}</tbody>`,
+    `</table></div>`,
+    `</section>`
+  ].join("\n");
+}
+function renderWorkflowReport(input) {
+  const warnings = input.warnings?.length ? `<section class="warnings"><h2>Warnings</h2><ul>${input.warnings.map((w) => `<li>${escapeHtml(w)}</li>`).join("")}</ul></section>` : "";
+  const sections = (input.sections ?? []).map((section) => `<section><h2>${escapeHtml(section.title)}</h2><p>${escapeHtml(section.body)}</p></section>`).join("\n");
+  const tables = (input.tables ?? []).map(renderTable).join("\n");
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    `<title>${escapeHtml(input.title)}</title>`,
+    "<style>",
+    ':root{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#172026;background:#f6f7f8}',
+    "body{margin:0;padding:32px}main{max-width:1180px;margin:0 auto;background:#fff;border:1px solid #d9dee3;border-radius:8px;padding:28px}",
+    "h1{font-size:30px;line-height:1.15;margin:0 0 8px}h2{font-size:18px;margin:28px 0 12px}p{line-height:1.55;color:#3d4952}.sub{color:#66737f;margin:0 0 20px}",
+    ".summary{background:#eef6f8;border-left:4px solid #12829a;padding:14px 16px;margin:20px 0}.warnings{background:#fff7e8;border-left:4px solid #c87b00;padding:12px 16px}",
+    ".table-wrap{overflow:auto;border:1px solid #dfe5ea;border-radius:8px}table{border-collapse:collapse;width:100%;font-size:13px}th,td{border-bottom:1px solid #edf0f2;padding:9px 10px;text-align:left;vertical-align:top}th{background:#f3f5f7;color:#31404c;position:sticky;top:0}tr:last-child td{border-bottom:0}",
+    "</style>",
+    "</head>",
+    "<body><main>",
+    `<h1>${escapeHtml(input.title)}</h1>`,
+    input.subtitle ? `<p class="sub">${escapeHtml(input.subtitle)}</p>` : "",
+    `<div class="summary">${escapeHtml(input.summary)}</div>`,
+    warnings,
+    sections,
+    tables,
+    "</main></body></html>"
+  ].join("\n");
+}
+
+// src/workflows/workflows/agent-packet.ts
+var AgentPacketInputSchema = z.object({
+  keyword: z.string().min(1),
+  domain: z.string().optional(),
+  location: z.string().optional(),
+  maxQuestions: z.number().int().min(1).max(200).default(40),
+  includeSerp: z.boolean().default(true),
+  includePaa: z.boolean().default(true),
+  includeAiOverview: z.boolean().default(true),
+  returnPartial: z.boolean().default(true)
+});
+function normalizeDomain(value) {
+  if (!value) return null;
+  try {
+    const url = new URL(value.includes("://") ? value : `https://${value}`);
+    return url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return value.replace(/^https?:\/\//, "").replace(/^www\./, "").split("/")[0]?.toLowerCase() || null;
+  }
+}
+function domainFromUrl(url) {
+  return normalizeDomain(url) ?? "";
+}
+function sourceRows(input, serp, paa) {
+  const target = normalizeDomain(input.domain);
+  const rows = [];
+  for (const result of serp?.organicResults ?? []) {
+    const domain = normalizeDomain(result.domain) ?? domainFromUrl(result.url);
+    rows.push({
+      surface: "organic",
+      position: result.position,
+      title: result.title,
+      url: result.url,
+      domain,
+      question: "",
+      answer_excerpt: result.snippet ?? "",
+      is_target: target ? domain === target : false,
+      is_competitor: target ? domain !== target : true
+    });
+  }
+  for (const row of paa?.flat ?? []) {
+    const url = row.source_cite ?? "";
+    const domain = normalizeDomain(row.source_site ?? "") ?? (url ? domainFromUrl(url) : "");
+    rows.push({
+      surface: "paa",
+      position: "",
+      title: row.source_title ?? row.source_site ?? "",
+      url,
+      domain,
+      question: row.question,
+      answer_excerpt: (row.answer ?? "").slice(0, 240),
+      is_target: target ? domain === target : false,
+      is_competitor: target ? Boolean(domain && domain !== target) : Boolean(domain)
+    });
+  }
+  for (const [i, cite] of (serp?.aiOverview?.citations ?? []).entries()) {
+    const url = cite.href ?? "";
+    const domain = url ? domainFromUrl(url) : "";
+    rows.push({
+      surface: "ai_overview",
+      position: i + 1,
+      title: cite.text ?? "",
+      url,
+      domain,
+      question: "",
+      answer_excerpt: "",
+      is_target: target ? domain === target : false,
+      is_competitor: target ? Boolean(domain && domain !== target) : Boolean(domain)
+    });
+  }
+  return rows;
+}
+function competitorRows(rows, targetDomain) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const domain = String(row.domain ?? "");
+    if (!domain || domain === targetDomain) continue;
+    const entry = byDomain.get(domain) ?? { organic: [], paa: 0, ai: 0, urls: /* @__PURE__ */ new Set() };
+    if (row.surface === "organic" && row.position) entry.organic.push(Number(row.position));
+    if (row.surface === "paa") entry.paa += 1;
+    if (row.surface === "ai_overview") entry.ai += 1;
+    if (row.url) entry.urls.add(String(row.url));
+    byDomain.set(domain, entry);
+  }
+  return [...byDomain.entries()].map(([domain, entry]) => ({
+    domain,
+    organic_best_position: entry.organic.length ? Math.min(...entry.organic) : "",
+    organic_count: entry.organic.length,
+    paa_mentions: entry.paa,
+    ai_overview_citations: entry.ai,
+    source_url_count: entry.urls.size
+  })).sort((a, b) => Number(a.organic_best_position || 999) - Number(b.organic_best_position || 999));
+}
+var agentPacketWorkflowDefinition = {
+  id: "agent-packet",
+  title: "Agent-Ready SEO Packet",
+  description: "Create an evidence folder for AI agents from live SERP/PAA/AI search surfaces.",
+  inputSchema: AgentPacketInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    const errors = [];
+    let serp = null;
+    let paa = null;
+    if (input.includeSerp) {
+      try {
+        serp = await ctx.client.post("/harvest/sync", {
+          query: input.keyword,
+          location: input.location,
+          serpOnly: true,
+          maxQuestions: 1,
+          format: "json"
+        }, 18e4);
+      } catch (err) {
+        warnings.push(`SERP evidence unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (input.includePaa) {
+      try {
+        paa = await ctx.client.post("/harvest/sync", {
+          query: input.keyword,
+          location: input.location,
+          maxQuestions: input.maxQuestions,
+          format: "json"
+        }, 28e4);
+      } catch (err) {
+        warnings.push(`PAA evidence unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (!serp && !paa && !input.returnPartial) throw new Error("No SEO evidence was collected");
+    const rows = sourceRows(input, serp, paa);
+    const target = normalizeDomain(input.domain);
+    const competitors = competitorRows(rows, target);
+    const evidence = {
+      input,
+      serp: serp ?? { status: "skipped" },
+      paa: paa ?? { status: "skipped" },
+      target: {
+        domain: target,
+        organicPositions: rows.filter((r) => r.surface === "organic" && r.is_target).map((r) => Number(r.position)),
+        citedInAiOverview: rows.some((r) => r.surface === "ai_overview" && r.is_target),
+        citedInPaa: rows.some((r) => r.surface === "paa" && r.is_target)
+      },
+      competitors,
+      warnings
+    };
+    await ctx.artifacts.writeJson("Evidence JSON", "evidence.json", evidence);
+    await ctx.artifacts.writeCsv("Sources CSV", "sources.csv", ["surface", "position", "title", "url", "domain", "question", "answer_excerpt", "is_target", "is_competitor"], rows);
+    await ctx.artifacts.writeCsv("Competitors CSV", "competitors.csv", ["domain", "organic_best_position", "organic_count", "paa_mentions", "ai_overview_citations", "source_url_count"], competitors);
+    const brief = [
+      `# SEO Evidence Brief: ${input.keyword}`,
+      "",
+      `Location: ${input.location ?? "not specified"}`,
+      `Target domain: ${target ?? "not specified"}`,
+      "",
+      "## Evidence Summary",
+      `- Organic rows: ${rows.filter((r) => r.surface === "organic").length}`,
+      `- PAA rows: ${rows.filter((r) => r.surface === "paa").length}`,
+      `- AI Overview citations: ${rows.filter((r) => r.surface === "ai_overview").length}`,
+      `- Competitor domains: ${competitors.length}`,
+      "",
+      "## Recommended Use",
+      "Use the CSV files as source of truth. Tie content recommendations to evidence rows and mark unsupported ideas as assumptions."
+    ].join("\n");
+    await ctx.artifacts.writeText("Brief", "brief.md", brief);
+    await ctx.artifacts.writeText("Agent tasks", "tasks.md", [
+      "# Agent Tasks",
+      "",
+      "- [ ] Read `evidence.json` before writing recommendations.",
+      "- [ ] Compare the target domain against `competitors.csv`.",
+      "- [ ] Use `sources.csv` for citations and source-grounded page sections.",
+      "- [ ] Mark unsupported recommendations as assumptions."
+    ].join("\n"));
+    await ctx.artifacts.writeText("Agent instructions", "agent-instructions.md", [
+      "# Agent Instructions",
+      "",
+      "You are working from an MCP Scraper SEO evidence packet. Use `evidence.json` and CSV files as source of truth. Do not invent citations. If a recommendation is not supported by evidence, mark it as an assumption."
+    ].join("\n"));
+    const summary = `${rows.length} evidence rows and ${competitors.length} competitor domains collected.`;
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "Agent-Ready SEO Packet",
+      subtitle: `${input.keyword}${input.location ? ` \xB7 ${input.location}` : ""}`,
+      summary,
+      warnings,
+      tables: [
+        { title: "Competitor Domains", columns: ["domain", "organic_best_position", "organic_count", "paa_mentions", "ai_overview_citations", "source_url_count"], rows: competitors.slice(0, 50) },
+        { title: "Evidence Sources", columns: ["surface", "position", "title", "domain", "question", "is_target"], rows: rows.slice(0, 100) }
+      ]
+    }));
+    const status = warnings.length ? "partial" : "succeeded";
+    const counts = { sources: rows.length, competitors: competitors.length };
+    await ctx.artifacts.writeManifest(status, counts, warnings, errors);
+    return { title: "Agent-Ready SEO Packet", summary, status, counts, warnings, errors, reportPath };
+  }
+};
+
+// src/workflows/workflows/directory.ts
+import { z as z2 } from "zod";
+var DirectoryWorkflowCliInputSchema = z2.object({
+  query: z2.string().min(1),
+  state: z2.string().min(2).default("TN"),
+  minPopulation: z2.number().int().min(0).default(1e5),
+  maxCities: z2.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z2.number().int().min(1).max(50).default(20),
+  concurrency: z2.number().int().min(1).max(5).default(5),
+  proxyMode: z2.enum(["location", "configured", "none"]).default("location"),
+  saveCsv: z2.boolean().default(true)
+});
+function directoryRows(result) {
+  const rows = [];
+  for (const city of result.cities) {
+    if (!city.results.length) {
+      rows.push({
+        source_query: result.query,
+        source_location: city.location,
+        city: city.city,
+        state: city.state,
+        population: city.population,
+        result_position: null,
+        business_name: null,
+        review_stars: null,
+        review_count: null,
+        category: null,
+        address: null,
+        phone: null,
+        website_url: null,
+        place_url: null,
+        cid: null,
+        cid_decimal: null,
+        result_status: city.status,
+        error: city.error
+      });
+      continue;
+    }
+    for (const business of city.results) {
+      rows.push({
+        source_query: result.query,
+        source_location: city.location,
+        city: city.city,
+        state: city.state,
+        population: city.population,
+        result_position: business.position,
+        business_name: business.name,
+        review_stars: business.rating,
+        review_count: business.reviewCount,
+        category: business.category,
+        address: business.address,
+        phone: business.phone,
+        website_url: business.websiteUrl,
+        place_url: business.placeUrl,
+        cid: business.cid,
+        cid_decimal: business.cidDecimal,
+        result_status: city.status,
+        error: city.error
+      });
+    }
+  }
+  return rows;
+}
+var DIRECTORY_CSV_HEADERS = [
+  "source_query",
+  "source_location",
+  "city",
+  "state",
+  "population",
+  "result_position",
+  "business_name",
+  "review_stars",
+  "review_count",
+  "category",
+  "address",
+  "phone",
+  "website_url",
+  "place_url",
+  "cid",
+  "cid_decimal",
+  "result_status",
+  "error"
+];
+var directoryWorkflowDefinition = {
+  id: "directory",
+  title: "Directory Workflow",
+  description: "Select city markets and export Google Maps business candidates.",
+  inputSchema: DirectoryWorkflowCliInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const result = await ctx.client.post("/directory/run", input, 9e5);
+    await ctx.artifacts.writeJson("Directory evidence", "evidence.json", result);
+    const rows = directoryRows(result);
+    await ctx.artifacts.writeCsv("Directory CSV", "exports/directory.csv", DIRECTORY_CSV_HEADERS, rows);
+    const cityRows = result.cities.map((city) => ({
+      city: city.city,
+      state: city.state,
+      population: city.population,
+      status: city.status,
+      result_count: city.resultCount,
+      error: city.error ?? ""
+    }));
+    const topRows = rows.filter((row) => row.business_name).slice(0, 100).map((row) => ({
+      city: row.city,
+      position: row.result_position,
+      business: row.business_name,
+      rating: row.review_stars,
+      reviews: row.review_count,
+      category: row.category,
+      website: row.website_url
+    }));
+    const summary = `${result.selectedCityCount} cities processed with ${result.totalResultCount} Maps results.`;
+    await ctx.artifacts.writeText("Summary", "summary.md", `# Directory Workflow
+
+${summary}
+`);
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "Directory Workflow",
+      subtitle: `${input.query} \xB7 ${input.state}`,
+      summary,
+      warnings: result.warnings,
+      tables: [
+        { title: "Cities", columns: ["city", "state", "population", "status", "result_count", "error"], rows: cityRows },
+        { title: "Top Results", columns: ["city", "position", "business", "rating", "reviews", "category", "website"], rows: topRows }
+      ]
+    }));
+    const status = result.cities.some((city) => city.status === "failed") ? "partial" : "succeeded";
+    const counts = { cities: result.selectedCityCount, results: result.totalResultCount, rows: rows.length };
+    await ctx.artifacts.writeManifest(status, counts, result.warnings, []);
+    return { title: "Directory Workflow", summary, status, counts, warnings: result.warnings, errors: [], reportPath };
+  }
+};
+
+// src/workflows/workflows/local-competitive-audit.ts
+import { z as z3 } from "zod";
+var LocalCompetitiveAuditInputSchema = z3.object({
+  query: z3.string().min(1),
+  state: z3.string().min(2).default("TN"),
+  minPopulation: z3.number().int().min(0).default(1e5),
+  maxCities: z3.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z3.number().int().min(1).max(50).default(20),
+  hydrateTop: z3.number().int().min(0).max(10).default(5),
+  maxReviews: z3.number().int().min(0).max(500).default(50),
+  concurrency: z3.number().int().min(1).max(5).default(5),
+  proxyMode: z3.enum(["location", "configured", "none"]).default("location"),
+  returnPartial: z3.boolean().default(true)
+});
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      out[index] = await fn(items[index], index);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return out;
+}
+function numberFrom(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(String(value).replace(/[^\d.]/g, ""));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function median(values) {
+  const nums = values.filter((v) => v !== null).sort((a, b) => a - b);
+  if (!nums.length) return null;
+  return nums[Math.floor(nums.length / 2)] ?? null;
+}
+function termsFrom(texts) {
+  const stop = /* @__PURE__ */ new Set(["the", "and", "for", "with", "that", "this", "was", "were", "are", "you", "our", "they", "had", "have", "not", "but", "from", "very", "great", "good"]);
+  const counts = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    for (const token of text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/)) {
+      if (token.length < 4 || stop.has(token)) continue;
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([term, count]) => `${term} (${count})`).join("; ");
+}
+var localCompetitiveAuditWorkflowDefinition = {
+  id: "local-competitive-audit",
+  title: "Local Competitive Audit",
+  description: "Audit local Maps competitors, categories, review counts, and review themes across city markets.",
+  inputSchema: LocalCompetitiveAuditInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    const errors = [];
+    const directory = await ctx.client.post("/directory/run", {
+      query: input.query,
+      state: input.state,
+      minPopulation: input.minPopulation,
+      maxCities: input.maxCities,
+      maxResultsPerCity: input.maxResultsPerCity,
+      concurrency: input.concurrency,
+      proxyMode: input.proxyMode,
+      saveCsv: true
+    }, 9e5);
+    await ctx.artifacts.writeJson("Directory raw JSON", "raw/directory-workflow.json", directory);
+    const baseRows = directoryRows(directory);
+    await ctx.artifacts.writeCsv("Base directory CSV", "exports/directory.csv", DIRECTORY_CSV_HEADERS, baseRows);
+    const selected = directory.cities.flatMap(
+      (city) => city.results.slice(0, input.hydrateTop).map((result) => ({ city, result }))
+    );
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = selected.filter(({ city, result }) => {
+      const key = result.cid ?? result.placeUrl ?? `${city.location}:${result.name.toLowerCase()}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    const hydrated = await mapLimit(deduped, 3, async ({ city, result }, index) => {
+      try {
+        const detail = await ctx.client.post("/maps/place", {
+          businessName: result.name,
+          location: city.location,
+          includeReviews: input.maxReviews > 0,
+          maxReviews: Math.max(1, input.maxReviews)
+        }, 18e4);
+        await ctx.artifacts.writeJson(`${result.name} profile`, `raw/maps-place-intel/${index + 1}-${result.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}.json`, detail);
+        return { city, result, detail, error: null };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warnings.push(`Profile hydration failed for ${result.name} (${city.location}): ${message}`);
+        return { city, result, detail: null, error: message };
+      }
+    });
+    const competitorRows2 = hydrated.map(({ city, result, detail, error }) => {
+      const reviews = detail?.reviews ?? [];
+      const ownerResponses = reviews.filter((r) => r.ownerResponse).length;
+      return {
+        city: city.city,
+        state: city.state,
+        source_location: city.location,
+        result_position: result.position,
+        business_name: result.name,
+        category: detail?.category ?? result.category,
+        review_stars: detail?.rating ?? result.rating,
+        review_count: detail?.reviewCount ?? result.reviewCount,
+        phone: result.phone,
+        website_url: detail?.website ?? result.websiteUrl,
+        place_url: result.placeUrl,
+        cid: result.cid,
+        cid_decimal: result.cidDecimal,
+        hydrated: detail ? "true" : "false",
+        reviews_status: detail?.reviewsStatus ?? "",
+        review_topics: (detail?.reviewTopics ?? []).map((t) => `${t.label} (${t.count})`).join("; "),
+        owner_response_rate: reviews.length ? (ownerResponses / reviews.length).toFixed(2) : "",
+        error: error ?? ""
+      };
+    });
+    const reviewInsightRows = hydrated.map(({ city, result, detail }) => {
+      const reviews = detail?.reviews ?? [];
+      const positive = reviews.filter((r) => Number(r.stars) >= 5 && r.text).map((r) => r.text);
+      const negative = reviews.filter((r) => Number(r.stars) > 0 && Number(r.stars) <= 3 && r.text).map((r) => r.text);
+      return {
+        city: city.city,
+        business_name: result.name,
+        cid: result.cid,
+        review_count: detail?.reviewCount ?? result.reviewCount,
+        average_rating: detail?.rating ?? result.rating,
+        topics: (detail?.reviewTopics ?? []).map((t) => `${t.label} (${t.count})`).join("; "),
+        praise_terms: termsFrom(positive),
+        complaint_terms: termsFrom(negative),
+        positive_sample: positive[0]?.slice(0, 280) ?? "",
+        negative_sample: negative[0]?.slice(0, 280) ?? ""
+      };
+    });
+    const citySummaryRows = directory.cities.map((city) => {
+      const resultReviewCounts = city.results.map((r) => numberFrom(r.reviewCount));
+      const resultRatings = city.results.map((r) => numberFrom(r.rating));
+      const topThreeReviews = city.results.slice(0, 3).map((r) => numberFrom(r.reviewCount)).filter((v) => v !== null);
+      const categories = /* @__PURE__ */ new Map();
+      for (const result of city.results) {
+        if (!result.category) continue;
+        categories.set(result.category, (categories.get(result.category) ?? 0) + 1);
+      }
+      const medReviews = median(resultReviewCounts);
+      const medRating = median(resultRatings);
+      const topThreeAvg = topThreeReviews.length ? Math.round(topThreeReviews.reduce((a, b) => a + b, 0) / topThreeReviews.length) : null;
+      const difficulty = Math.min(100, Math.round((topThreeAvg ?? 0) / 20 + (medRating ?? 0) * 10 + city.results.filter((r) => r.websiteUrl).length));
+      const opportunity = Math.max(0, 100 - difficulty);
+      return {
+        city: city.city,
+        state: city.state,
+        population: city.population,
+        result_count: city.resultCount,
+        median_review_count: medReviews ?? "",
+        median_rating: medRating ?? "",
+        top_three_average_review_count: topThreeAvg ?? "",
+        top_categories: [...categories.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([cat, count]) => `${cat} (${count})`).join("; "),
+        opportunity_score: opportunity,
+        difficulty_score: difficulty
+      };
+    });
+    await ctx.artifacts.writeCsv("Competitors CSV", "competitors.csv", ["city", "state", "source_location", "result_position", "business_name", "category", "review_stars", "review_count", "phone", "website_url", "place_url", "cid", "cid_decimal", "hydrated", "reviews_status", "review_topics", "owner_response_rate", "error"], competitorRows2);
+    await ctx.artifacts.writeCsv("Review insights CSV", "review-insights.csv", ["city", "business_name", "cid", "review_count", "average_rating", "topics", "praise_terms", "complaint_terms", "positive_sample", "negative_sample"], reviewInsightRows);
+    await ctx.artifacts.writeCsv("City summary CSV", "city-summary.csv", ["city", "state", "population", "result_count", "median_review_count", "median_rating", "top_three_average_review_count", "top_categories", "opportunity_score", "difficulty_score"], citySummaryRows);
+    await ctx.artifacts.writeJson("Audit evidence", "evidence.json", { input, directory, hydrated, citySummaryRows, competitorRows: competitorRows2, reviewInsightRows });
+    await ctx.artifacts.writeText("Agent tasks", "tasks.md", [
+      "# Local Competitive Audit Tasks",
+      "",
+      "- [ ] Review city opportunity and difficulty scores as heuristics, not absolute truth.",
+      "- [ ] Use review topics and samples as customer-language evidence.",
+      "- [ ] Compare target GBP category, review count, and website quality against top competitors.",
+      "- [ ] Identify cities with low review-count leaders and weak website coverage."
+    ].join("\n"));
+    const summary = `${directory.selectedCityCount} cities, ${directory.totalResultCount} Maps results, ${hydrated.filter((h) => h.detail).length} hydrated profiles.`;
+    await ctx.artifacts.writeText("Summary", "summary.md", `# Local Competitive Audit
+
+${summary}
+`);
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "Local Competitive Audit",
+      subtitle: `${input.query} \xB7 ${input.state}`,
+      summary,
+      warnings,
+      tables: [
+        { title: "City Opportunity", columns: ["city", "state", "population", "result_count", "median_review_count", "median_rating", "top_three_average_review_count", "top_categories", "opportunity_score", "difficulty_score"], rows: citySummaryRows },
+        { title: "Hydrated Competitors", columns: ["city", "result_position", "business_name", "category", "review_stars", "review_count", "hydrated", "review_topics"], rows: competitorRows2.slice(0, 100) },
+        { title: "Review Insights", columns: ["city", "business_name", "topics", "praise_terms", "complaint_terms"], rows: reviewInsightRows.slice(0, 100) }
+      ]
+    }));
+    const status = warnings.length || directory.cities.some((city) => city.status === "failed") ? "partial" : "succeeded";
+    const counts = { cities: directory.selectedCityCount, mapsResults: directory.totalResultCount, hydratedProfiles: hydrated.filter((h) => h.detail).length };
+    await ctx.artifacts.writeManifest(status, counts, warnings, errors);
+    return { title: "Local Competitive Audit", summary, status, counts, warnings, errors, reportPath };
+  }
+};
+
+// src/workflows/registry.ts
+var DEFINITIONS = [
+  directoryWorkflowDefinition,
+  agentPacketWorkflowDefinition,
+  localCompetitiveAuditWorkflowDefinition
+];
+function listWorkflowDefinitions() {
+  return DEFINITIONS.map(({ id, title, description }) => ({ id, title, description }));
+}
+function workflowDefinition(id) {
+  const definition = DEFINITIONS.find((def) => def.id === id);
+  if (!definition) throw new Error(`Unknown workflow "${id}". Available: ${DEFINITIONS.map((def) => def.id).join(", ")}`);
+  return definition;
+}
+async function runWorkflow(id, rawInput, options = {}) {
+  const definition = workflowDefinition(id);
+  const input = definition.inputSchema.parse(rawInput);
+  const apiKey = options.apiKey?.trim() || process.env.MCP_SCRAPER_API_KEY?.trim();
+  if (!apiKey) throw new Error("MCP_SCRAPER_API_KEY is required for workflow runs. Pass --api-key or set the environment variable.");
+  const apiUrl = options.apiUrl?.trim() || process.env.MCP_SCRAPER_API_URL?.trim() || "https://mcpscraper.dev";
+  const artifacts = await ArtifactWriter.create(definition.id, definition.title, input, options.outputDir, options.runId);
+  const client = new WorkflowHttpClient(apiUrl, apiKey, options.fetchImpl);
+  try {
+    return await definition.run(input, {
+      runId: artifacts.runId,
+      startedAt: artifacts.startedAt,
+      client,
+      artifacts,
+      signal: options.signal
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await artifacts.writeText("Failure", "summary.md", `# ${definition.title}
+
+${message}
+`);
+    await artifacts.writeManifest("failed", {}, [], [message]);
+    throw err;
+  }
+}
+
+export {
+  csvRecords,
+  rowsToCsv,
+  workflowOutputBaseDir,
+  listWorkflowReports,
+  findWorkflowReport,
+  openWorkflowReport,
+  listWorkflowDefinitions,
+  workflowDefinition,
+  runWorkflow
+};
+//# sourceMappingURL=chunk-L6IS63WS.js.map