salesprompter-cli 0.1.6 → 0.1.7

package/README.md

@@ -19,9 +19,16 @@ It is built for two users at the same time:
 
 ## Start Here
 
-If someone discovers Salesprompter from a vague prompt, the first thing they need is the shortest working path.
+If someone discovers Salesprompter from a vague prompt, give them the shortest working path for their context.
 
 ```bash
+## Human-friendly guided path
+npx -y salesprompter-cli@latest
+
+## Explicit guided path
+npx -y salesprompter-cli@latest wizard
+
+## Raw command surface for agents and scripts
 npx salesprompter-cli@latest --help
 ```
 
@@ -29,9 +36,13 @@ Or install it globally:
 
 ```bash
 npm install -g salesprompter-cli
+salesprompter
+salesprompter wizard
 salesprompter --help
 ```
 
+Bare `salesprompter` now opens a guided wizard in an interactive terminal. Keep using explicit subcommands for agents, CI, and copy-paste docs.
+
 ## Prompt To Command
 
 If the user says something like "I need to determine the ICP of deel.com", there are two different meanings.

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
+import { createInterface } from "node:readline/promises";
 import { Command } from "commander";
 import { z } from "zod";
 import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, requireAuthSession, shouldBypassAuth, verifySession } from "./auth.js";
@@ -89,6 +90,386 @@ function writeBrowserLoginInstructions(info) {
         process.stderr.write("Opened the browser for you.\n");
     }
 }
+async function performLogin(options) {
+    const token = typeof options.token === "string" ? options.token.trim() : "";
+    if (token.length > 0) {
+        const session = await loginWithToken(token, options.apiUrl);
+        return {
+            method: "token",
+            session
+        };
+    }
+    const startedAt = new Date().toISOString();
+    try {
+        const session = await loginWithBrowserConnect({
+            apiBaseUrl: options.apiUrl,
+            timeoutSeconds: options.timeoutSeconds,
+            onConnectStart: writeBrowserLoginInstructions
+        });
+        return {
+            method: "browser",
+            startedAt,
+            session
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("timed out waiting for browser login") &&
+            !message.includes("invalid localhost callback response") &&
+            !message.includes("request failed")) {
+            throw error;
+        }
+        if (!/request failed \((401|403|404|405|500|501|502|503|504)\)/.test(message)) {
+            throw error;
+        }
+    }
+    const result = await loginWithDeviceFlow({
+        apiBaseUrl: options.apiUrl,
+        timeoutSeconds: options.timeoutSeconds,
+        onDeviceStart: writeDeviceLoginInstructions
+    });
+    return {
+        method: "device",
+        startedAt,
+        verificationUrl: result.verificationUrl,
+        userCode: result.userCode,
+        session: result.session
+    };
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:@=-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function buildCommandLine(args) {
+    return args.map((arg) => shellQuote(arg)).join(" ");
+}
+function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .split("/")[0]
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function normalizeDomainInput(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .split("/")[0] ?? "";
+}
+function deriveCompanyNameFromDomain(domain) {
+    const hostname = normalizeDomainInput(domain).split(".")[0] ?? domain;
+    return hostname
+        .split(/[-_]/)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+}
+function writeWizardLine(message = "") {
+    process.stdout.write(`${message}\n`);
+}
+async function promptChoice(rl, prompt, options, defaultValue) {
+    const defaultIndex = options.findIndex((option) => option.value === defaultValue);
+    if (defaultIndex === -1) {
+        throw new Error(`wizard default option is invalid for ${prompt}`);
+    }
+    while (true) {
+        writeWizardLine(prompt);
+        for (const [index, option] of options.entries()) {
+            const description = option.description ? ` - ${option.description}` : "";
+            writeWizardLine(`  ${index + 1}. ${option.label}${description}`);
+        }
+        const answer = (await rl.question(`Choose [1-${options.length}] (default ${defaultIndex + 1}): `)).trim();
+        if (answer.length === 0) {
+            return defaultValue;
+        }
+        const numeric = Number(answer);
+        if (Number.isInteger(numeric) && numeric >= 1 && numeric <= options.length) {
+            const selected = options[numeric - 1];
+            if (!selected) {
+                throw new Error("wizard selection invariant violated");
+            }
+            return selected.value;
+        }
+        const matched = options.find((option) => option.value.toLowerCase() === answer.toLowerCase());
+        if (matched) {
+            return matched.value;
+        }
+        writeWizardLine("Please choose one of the numbered options.");
+        writeWizardLine();
+    }
+}
+async function promptText(rl, prompt, options = {}) {
+    while (true) {
+        const suffix = options.defaultValue !== undefined ? ` [${options.defaultValue}]` : "";
+        const answer = (await rl.question(`${prompt}${suffix}: `)).trim();
+        if (answer.length > 0) {
+            return answer;
+        }
+        if (options.defaultValue !== undefined) {
+            return options.defaultValue;
+        }
+        if (!options.required) {
+            return "";
+        }
+        writeWizardLine("This field is required.");
+    }
+}
+async function promptYesNo(rl, prompt, defaultValue) {
+    while (true) {
+        const answer = (await rl.question(`${prompt} [${defaultValue ? "Y/n" : "y/N"}]: `)).trim().toLowerCase();
+        if (answer.length === 0) {
+            return defaultValue;
+        }
+        if (["y", "yes"].includes(answer)) {
+            return true;
+        }
+        if (["n", "no"].includes(answer)) {
+            return false;
+        }
+        writeWizardLine("Please answer yes or no.");
+    }
+}
+async function ensureWizardSession(options) {
+    if (shouldBypassAuth()) {
+        return null;
+    }
+    try {
+        const session = await requireAuthSession();
+        writeWizardLine(`Signed in as ${session.user.email}.`);
+        writeWizardLine();
+        return session;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("not logged in") && !message.includes("session expired")) {
+            throw error;
+        }
+    }
+    writeWizardLine("No active Salesprompter session found. Starting login...");
+    writeWizardLine();
+    const result = await performLogin({
+        apiUrl: options?.apiUrl,
+        timeoutSeconds: options?.timeoutSeconds ?? 180
+    });
+    writeWizardLine(`Signed in as ${result.session.user.email}.`);
+    writeWizardLine();
+    return result.session;
+}
+async function runVendorIcpWizard(rl) {
+    const vendor = await promptChoice(rl, "Which vendor template do you want?", [{ value: "deel", label: "Deel", description: "Global payroll, EOR, and contractor workflows" }], "deel");
+    writeWizardLine();
+    const market = await promptChoice(rl, "Which market should this ICP target?", [
+        { value: "dach", label: "DACH", description: "Germany, Austria, Switzerland" },
+        { value: "europe", label: "Europe" },
+        { value: "global", label: "Global" }
+    ], "dach");
+    writeWizardLine();
+    const outPath = await promptText(rl, "Where should I save the ICP JSON?", {
+        defaultValue: `./data/${slugify(vendor)}-icp-${market}.json`,
+        required: true
+    });
+    writeWizardLine();
+    const icp = buildVendorIcp(vendor, market);
+    await writeJsonFile(outPath, icp);
+    writeWizardLine(`Created ${icp.name}.`);
+    writeWizardLine(`Saved ICP to ${outPath}.`);
+    writeWizardLine();
+    writeWizardLine("Equivalent raw command:");
+    writeWizardLine(`  ${buildCommandLine(["salesprompter", "icp:vendor", "--vendor", vendor, "--market", market, "--out", outPath])}`);
+    writeWizardLine();
+    writeWizardLine("Next suggested command:");
+    writeWizardLine(`  ${buildCommandLine([
+        "salesprompter",
+        "leads:lookup:bq",
+        "--icp",
+        outPath,
+        "--limit",
+        "100",
+        "--lead-out",
+        `./data/${slugify(vendor)}-leads.json`
+    ])}`);
+}
+async function runTargetAccountWizard(rl) {
+    const domain = normalizeDomainInput(await promptText(rl, "Which company domain are you targeting?", { required: true }));
+    writeWizardLine();
+    const companyName = await promptText(rl, "Company name override (optional)");
+    const displayName = companyName || deriveCompanyNameFromDomain(domain);
+    const leadCount = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many leads should I generate?", { defaultValue: "5", required: true }));
+    const region = await promptText(rl, "Primary region hint", { defaultValue: "Global", required: true });
+    const industries = await promptText(rl, "Industry hint (optional, comma-separated)");
+    const titles = await promptText(rl, "Target titles (optional, comma-separated)");
+    writeWizardLine();
+    const slug = slugify(domain);
+    const icpPath = await promptText(rl, "Where should I save the ad-hoc ICP JSON?", {
+        defaultValue: `./data/${slug}-target-icp.json`,
+        required: true
+    });
+    const leadsPath = await promptText(rl, "Where should I save the generated leads JSON?", {
+        defaultValue: `./data/${slug}-leads.json`,
+        required: true
+    });
+    writeWizardLine();
+    const icp = IcpSchema.parse({
+        name: `${displayName} target account`,
+        regions: region.length > 0 ? [region] : [],
+        industries: splitCsv(industries),
+        titles: splitCsv(titles)
+    });
+    await writeJsonFile(icpPath, icp);
+    const result = await leadProvider.generateLeads(icp, leadCount, {
+        companyDomain: domain,
+        companyName: companyName || undefined
+    });
+    await writeJsonFile(leadsPath, result.leads);
+    writeWizardLine(`Generated ${result.leads.length} leads for ${result.account.companyName} (${result.account.domain}).`);
+    writeWizardLine(`Saved ad-hoc ICP to ${icpPath}.`);
+    writeWizardLine(`Saved leads to ${leadsPath}.`);
+    if (result.warnings.length > 0) {
+        writeWizardLine();
+        writeWizardLine(`Warning: ${result.warnings.join(" ")}`);
+    }
+    writeWizardLine();
+    writeWizardLine("Equivalent raw commands:");
+    const defineArgs = ["salesprompter", "icp:define", "--name", icp.name];
+    if (region.length > 0) {
+        defineArgs.push("--regions", region);
+    }
+    if (industries.trim().length > 0) {
+        defineArgs.push("--industries", industries);
+    }
+    if (titles.trim().length > 0) {
+        defineArgs.push("--titles", titles);
+    }
+    defineArgs.push("--out", icpPath);
+    writeWizardLine(`  ${buildCommandLine(defineArgs)}`);
+    const leadArgs = ["salesprompter", "leads:generate", "--icp", icpPath, "--count", String(leadCount), "--domain", domain];
+    if (companyName.trim().length > 0) {
+        leadArgs.push("--company-name", companyName);
+    }
+    leadArgs.push("--out", leadsPath);
+    writeWizardLine(`  ${buildCommandLine(leadArgs)}`);
+}
+async function runVendorLookupWizard(rl) {
+    const vendor = await promptChoice(rl, "Which vendor template do you want to use?", [{ value: "deel", label: "Deel", description: "Global payroll, EOR, and contractor workflows" }], "deel");
+    writeWizardLine();
+    const market = await promptChoice(rl, "Which market should the BigQuery lookup target?", [
+        { value: "dach", label: "DACH", description: "Germany, Austria, Switzerland" },
+        { value: "europe", label: "Europe" },
+        { value: "global", label: "Global" }
+    ], "dach");
+    const limit = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many rows should the lookup return?", { defaultValue: "100", required: true }));
+    const execute = await promptYesNo(rl, "Execute the BigQuery lookup now?", false);
+    writeWizardLine();
+    const slug = slugify(vendor);
+    const icpPath = await promptText(rl, "Where should I save the ICP JSON?", {
+        defaultValue: `./data/${slug}-icp-${market}.json`,
+        required: true
+    });
+    const sqlPath = await promptText(rl, "Where should I save the generated SQL?", {
+        defaultValue: `./data/${slug}-lookup-${market}.sql`,
+        required: true
+    });
+    const rawPath = execute
+        ? await promptText(rl, "Where should I save raw BigQuery rows?", {
+            defaultValue: `./data/${slug}-leads-raw-${market}.json`,
+            required: true
+        })
+        : "";
+    const leadPath = execute
+        ? await promptText(rl, "Where should I save normalized leads?", {
+            defaultValue: `./data/${slug}-leads-${market}.json`,
+            required: true
+        })
+        : "";
+    writeWizardLine();
+    const icp = buildVendorIcp(vendor, market);
+    await writeJsonFile(icpPath, icp);
+    const sql = buildBigQueryLeadLookupSql(icp, {
+        table: "icpidentifier.SalesGPT.leadPool_new",
+        companyField: "companyName",
+        domainField: "domain",
+        regionField: undefined,
+        keywordFields: splitCsv("companyName,industry,description,tagline,specialties"),
+        titleField: "jobTitle",
+        industryField: "industry",
+        companySizeField: "companySize",
+        countryField: "company_countryCode",
+        firstNameField: "firstName",
+        lastNameField: "lastName",
+        emailField: "email",
+        limit,
+        additionalWhere: undefined,
+        useSalesprompterGuards: true
+    });
+    await writeTextFile(sqlPath, `${sql}\n`);
+    let executedRowCount = null;
+    if (execute) {
+        const rows = await runBigQueryQuery(sql, { maxRows: limit });
+        const parsedRows = z.array(z.record(z.string(), z.unknown())).parse(rows);
+        await writeJsonFile(rawPath, parsedRows);
+        const normalizedLeads = normalizeBigQueryLeadRows(parsedRows);
+        await writeJsonFile(leadPath, normalizedLeads);
+        executedRowCount = parsedRows.length;
+    }
+    writeWizardLine(`Saved vendor ICP to ${icpPath}.`);
+    writeWizardLine(`Saved lookup SQL to ${sqlPath}.`);
+    if (execute) {
+        writeWizardLine(`Saved ${executedRowCount ?? 0} raw rows to ${rawPath}.`);
+        writeWizardLine(`Saved normalized leads to ${leadPath}.`);
+    }
+    writeWizardLine();
+    writeWizardLine("Equivalent raw commands:");
+    writeWizardLine(`  ${buildCommandLine(["salesprompter", "icp:vendor", "--vendor", vendor, "--market", market, "--out", icpPath])}`);
+    const lookupArgs = ["salesprompter", "leads:lookup:bq", "--icp", icpPath, "--limit", String(limit), "--sql-out", sqlPath];
+    if (execute) {
+        lookupArgs.push("--execute", "--out", rawPath, "--lead-out", leadPath);
+    }
+    writeWizardLine(`  ${buildCommandLine(lookupArgs)}`);
+}
+async function runWizard(options) {
+    if (runtimeOutputOptions.json || runtimeOutputOptions.quiet) {
+        throw new Error("wizard does not support --json or --quiet.");
+    }
+    writeWizardLine("Salesprompter Wizard");
+    writeWizardLine("Choose a workflow and I will map it to the underlying CLI commands.");
+    writeWizardLine();
+    await ensureWizardSession(options);
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        const flow = await promptChoice(rl, "What do you want to do?", [
+            { value: "vendor-icp", label: "Create a vendor ICP template", description: "Best for prompts like \"determine Deel's ICP\"" },
+            { value: "target-account", label: "Generate leads for a target company", description: "Best for prompts like \"find contacts at deel.com\"" },
+            { value: "vendor-lookup", label: "Create a vendor ICP and prepare a BigQuery lookup", description: "Best for warehouse-backed lead discovery" }
+        ], "vendor-icp");
+        writeWizardLine();
+        if (flow === "vendor-icp") {
+            await runVendorIcpWizard(rl);
+            return;
+        }
+        if (flow === "target-account") {
+            await runTargetAccountWizard(rl);
+            return;
+        }
+        await runVendorLookupWizard(rl);
+    }
+    finally {
+        rl.close();
+    }
+}
+function shouldAutoRunWizard(argv) {
+    return argv.length <= 2 && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
 function buildCliError(error) {
     if (error instanceof z.ZodError) {
         return {
@@ -234,53 +615,15 @@ program
     .option("--timeout-seconds <number>", "Device flow wait timeout in seconds", "180")
     .action(async (options) => {
     const timeoutSeconds = z.coerce.number().int().min(30).max(1800).parse(options.timeoutSeconds);
-    const token = typeof options.token === "string" ? options.token.trim() : "";
-    if (token.length > 0) {
-        const session = await loginWithToken(token, options.apiUrl);
-        printOutput({
-            status: "ok",
-            method: "token",
-            apiBaseUrl: session.apiBaseUrl,
-            user: session.user,
-            expiresAt: session.expiresAt ?? null
-        });
-        return;
-    }
-    const startedAt = new Date().toISOString();
-    try {
-        const session = await loginWithBrowserConnect({
-            apiBaseUrl: options.apiUrl,
-            timeoutSeconds,
-            onConnectStart: writeBrowserLoginInstructions
-        });
-        printOutput({
-            status: "ok",
-            method: "browser",
-            startedAt,
-            apiBaseUrl: session.apiBaseUrl,
-            user: session.user,
-            expiresAt: session.expiresAt ?? null
-        });
-        return;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (!message.includes("timed out waiting for browser login") && !message.includes("invalid localhost callback response") && !message.includes("request failed")) {
-            throw error;
-        }
-        if (!/request failed \((401|403|404|405|500|501|502|503|504)\)/.test(message)) {
-            throw error;
-        }
-    }
-    const result = await loginWithDeviceFlow({
-        apiBaseUrl: options.apiUrl,
-        timeoutSeconds,
-        onDeviceStart: writeDeviceLoginInstructions
+    const result = await performLogin({
+        token: options.token,
+        apiUrl: options.apiUrl,
+        timeoutSeconds
     });
     printOutput({
         status: "ok",
-        method: "device",
-        startedAt,
+        method: result.method,
+        startedAt: result.startedAt,
         verificationUrl: result.verificationUrl,
         userCode: result.userCode,
         apiBaseUrl: result.session.apiBaseUrl,
@@ -288,6 +631,19 @@ program
         expiresAt: result.session.expiresAt ?? null
     });
 });
+program
+    .command("wizard")
+    .alias("start")
+    .description("Run an interactive guided workflow for common Salesprompter tasks.")
+    .option("--api-url <url>", "Salesprompter API base URL, defaults to SALESPROMPTER_API_BASE_URL or salesprompter.ai")
+    .option("--timeout-seconds <number>", "Auth login timeout in seconds when the wizard needs to sign in", "180")
+    .action(async (options) => {
+    const timeoutSeconds = z.coerce.number().int().min(30).max(1800).parse(options.timeoutSeconds);
+    await runWizard({
+        apiUrl: options.apiUrl,
+        timeoutSeconds
+    });
+});
 program
     .command("auth:whoami")
     .description("Show current authenticated user and session status.")
@@ -313,7 +669,7 @@ program
 program.hook("preAction", async (_thisCommand, actionCommand) => {
     applyGlobalOutputOptions(actionCommand);
     const commandName = actionCommand.name();
-    if (commandName.startsWith("auth:")) {
+    if (commandName.startsWith("auth:") || commandName === "wizard") {
         return;
     }
     if (shouldBypassAuth()) {
@@ -980,7 +1336,18 @@ program
         execution
     });
 });
-program.parseAsync(process.argv).catch((error) => {
+async function main() {
+    if (shouldAutoRunWizard(process.argv)) {
+        await runWizard();
+        return;
+    }
+    if (process.argv.length <= 2) {
+        program.outputHelp();
+        return;
+    }
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
     const cliError = buildCliError(error);
     const space = runtimeOutputOptions.json ? undefined : 2;
     if (runtimeOutputOptions.json) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesprompter-cli",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "JSON-first sales prospecting CLI for ICP definition, lead generation, enrichment, scoring, and CRM/outreach sync.",
   "type": "module",
   "bin": {