salesprompter-cli 0.1.0

package/dist-tests/tests/cli.test.js

@@ -0,0 +1,149 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const projectRoot = path.resolve(import.meta.dirname, "..", "..");
+const cliPath = path.join(projectRoot, "dist", "cli.js");
+async function runCli(args) {
+    const { stdout } = await execFileAsync("node", [cliPath, ...args], {
+        cwd: projectRoot
+    });
+    return JSON.parse(stdout);
+}
+test("CLI help renders the expected command surface", async () => {
+    const { stdout } = await execFileAsync("node", [cliPath, "--help"], {
+        cwd: projectRoot
+    });
+    assert.match(stdout, /icp:define/);
+    assert.match(stdout, /leads:generate/);
+    assert.match(stdout, /sync:outreach/);
+});
+test("CLI workflow generates, enriches, scores, and syncs leads", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "salesprompter-cli-"));
+    try {
+        const icpPath = path.join(tempDir, "icp.json");
+        const leadsPath = path.join(tempDir, "leads.json");
+        const enrichedPath = path.join(tempDir, "enriched.json");
+        const scoredPath = path.join(tempDir, "scored.json");
+        const icpResult = await runCli([
+            "icp:define",
+            "--name",
+            "EU SaaS RevOps",
+            "--industries",
+            "Software,Financial Services",
+            "--company-sizes",
+            "50-199,200-499",
+            "--regions",
+            "Europe",
+            "--titles",
+            "Head of Revenue Operations,VP Sales",
+            "--required-signals",
+            "recent funding,growing outbound team",
+            "--out",
+            icpPath
+        ]);
+        assert.equal(icpResult.status, "ok");
+        const generateResult = await runCli([
+            "leads:generate",
+            "--icp",
+            icpPath,
+            "--count",
+            "4",
+            "--out",
+            leadsPath
+        ]);
+        assert.equal(generateResult.generated, 4);
+        const enrichResult = await runCli([
+            "leads:enrich",
+            "--in",
+            leadsPath,
+            "--out",
+            enrichedPath
+        ]);
+        assert.equal(enrichResult.enriched, 4);
+        const scoreResult = await runCli([
+            "leads:score",
+            "--icp",
+            icpPath,
+            "--in",
+            enrichedPath,
+            "--out",
+            scoredPath
+        ]);
+        assert.equal(scoreResult.scored, 4);
+        const crmSyncResult = await runCli([
+            "sync:crm",
+            "--target",
+            "hubspot",
+            "--in",
+            scoredPath
+        ]);
+        assert.deepEqual(crmSyncResult, {
+            status: "ok",
+            target: "hubspot",
+            synced: 4,
+            dryRun: true
+        });
+        const scoredLeads = JSON.parse(await readFile(scoredPath, "utf8"));
+        assert.equal(scoredLeads.length, 4);
+        assert.ok(scoredLeads.every((lead) => lead.score >= 0 && lead.score <= 100));
+        assert.ok(scoredLeads.every((lead) => ["A", "B", "C", "D"].includes(lead.grade)));
+        assert.ok(scoredLeads.some((lead) => lead.rationale.length > 0));
+        assert.ok(scoredLeads.some((lead) => lead.crmFit === "high" || lead.outreachFit === "high"));
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+});
+test("CLI can target a specific company domain like deel.com", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "salesprompter-cli-target-"));
+    try {
+        const icpPath = path.join(tempDir, "icp.json");
+        const leadsPath = path.join(tempDir, "deel-leads.json");
+        await runCli([
+            "icp:define",
+            "--name",
+            "Global HR Tech",
+            "--industries",
+            "Software",
+            "--regions",
+            "Global",
+            "--titles",
+            "VP Sales,Head of Revenue Operations",
+            "--out",
+            icpPath
+        ]);
+        const generateResult = await runCli([
+            "leads:generate",
+            "--icp",
+            icpPath,
+            "--count",
+            "3",
+            "--company-domain",
+            "deel.com",
+            "--company-name",
+            "Deel",
+            "--out",
+            leadsPath
+        ]);
+        assert.deepEqual(generateResult, {
+            status: "ok",
+            generated: 3,
+            out: leadsPath,
+            target: "deel.com"
+        });
+        const leads = JSON.parse(await readFile(leadsPath, "utf8"));
+        assert.equal(leads.length, 3);
+        assert.ok(leads.every((lead) => lead.companyName === "Deel"));
+        assert.ok(leads.every((lead) => lead.domain === "deel.com"));
+        assert.ok(leads.every((lead) => lead.email.endsWith("@deel.com")));
+        assert.ok(leads.every((lead) => lead.source === "heuristic-target-account"));
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "salesprompter-cli",
+  "version": "0.1.0",
+  "description": "CLI for defining ICPs, generating leads, enriching them, scoring them, and syncing to GTM tools.",
+  "type": "module",
+  "bin": {
+    "salesprompter": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "start": "node ./dist/cli.js",
+    "test": "npm run build && tsc -p tsconfig.test.json && node --test dist-tests/tests/**/*.test.js"
+  },
+  "keywords": [
+    "sales",
+    "cli",
+    "lead-generation",
+    "crm",
+    "outreach"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^14.0.1",
+    "zod": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "typescript": "^5.9.2"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { z } from "zod";
+import {
+  EnrichedLeadSchema,
+  IcpSchema,
+  LeadSchema,
+  ScoredLeadSchema,
+  SyncTargetSchema
+} from "./domain.js";
+import { DryRunSyncProvider, HeuristicEnrichmentProvider, HeuristicLeadProvider, HeuristicScoringProvider } from "./engine.js";
+import { readJsonFile, splitCsv, writeJsonFile } from "./io.js";
+import type { LeadGenerationTarget } from "./providers.js";
+
+const program = new Command();
+const leadProvider = new HeuristicLeadProvider();
+const enrichmentProvider = new HeuristicEnrichmentProvider();
+const scoringProvider = new HeuristicScoringProvider();
+const syncProvider = new DryRunSyncProvider();
+
+function printOutput(value: unknown): void {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+program
+  .name("salesprompter")
+  .description("Sales workflow CLI for ICP definition, lead generation, enrichment, scoring, and sync.")
+  .version("0.1.0");
+
+program
+  .command("icp:define")
+  .description("Define an ideal customer profile and write it to a JSON file.")
+  .requiredOption("--name <name>", "Human-readable ICP name")
+  .option("--industries <items>", "Comma-separated industries", "")
+  .option("--company-sizes <items>", "Comma-separated buckets like 1-49,50-199,200-499,500+", "")
+  .option("--regions <items>", "Comma-separated regions", "")
+  .option("--titles <items>", "Comma-separated titles", "")
+  .option("--pains <items>", "Comma-separated pain points", "")
+  .option("--required-signals <items>", "Comma-separated required signals", "")
+  .option("--excluded-signals <items>", "Comma-separated excluded signals", "")
+  .requiredOption("--out <path>", "Output file path")
+  .action(async (options) => {
+    const icp = IcpSchema.parse({
+      name: options.name,
+      industries: splitCsv(options.industries),
+      companySizes: splitCsv(options.companySizes),
+      regions: splitCsv(options.regions),
+      titles: splitCsv(options.titles),
+      pains: splitCsv(options.pains),
+      requiredSignals: splitCsv(options.requiredSignals),
+      excludedSignals: splitCsv(options.excludedSignals)
+    });
+
+    await writeJsonFile(options.out, icp);
+    printOutput({ status: "ok", icp });
+  });
+
+program
+  .command("leads:generate")
+  .description("Generate seed leads against an ICP.")
+  .requiredOption("--icp <path>", "Path to ICP JSON")
+  .option("--count <number>", "Number of leads to generate", "10")
+  .option("--company-domain <domain>", "Target a specific company domain like deel.com")
+  .option("--company-name <name>", "Optional company name override for a targeted domain")
+  .requiredOption("--out <path>", "Output file path")
+  .action(async (options) => {
+    const icp = await readJsonFile(options.icp, IcpSchema);
+    const count = z.coerce.number().int().min(1).max(1000).parse(options.count);
+    const target: LeadGenerationTarget = {
+      companyDomain: options.companyDomain,
+      companyName: options.companyName
+    };
+    const leads = await leadProvider.generateLeads(icp, count, target);
+
+    await writeJsonFile(options.out, leads);
+    printOutput({ status: "ok", generated: leads.length, out: options.out, target: target.companyDomain ?? null });
+  });
+
+program
+  .command("leads:enrich")
+  .description("Enrich leads with fit, buying stage, and tech stack data.")
+  .requiredOption("--in <path>", "Path to lead JSON array")
+  .requiredOption("--out <path>", "Output file path")
+  .action(async (options) => {
+    const leads = await readJsonFile(options.in, z.array(LeadSchema));
+    const enriched = await enrichmentProvider.enrichLeads(leads);
+
+    await writeJsonFile(options.out, enriched);
+    printOutput({ status: "ok", enriched: enriched.length, out: options.out });
+  });
+
+program
+  .command("leads:score")
+  .description("Score enriched leads against an ICP.")
+  .requiredOption("--icp <path>", "Path to ICP JSON")
+  .requiredOption("--in <path>", "Path to enriched lead JSON array")
+  .requiredOption("--out <path>", "Output file path")
+  .action(async (options) => {
+    const icp = await readJsonFile(options.icp, IcpSchema);
+    const leads = await readJsonFile(options.in, z.array(EnrichedLeadSchema));
+    const scored = await scoringProvider.scoreLeads(icp, leads);
+
+    await writeJsonFile(options.out, scored);
+    printOutput({ status: "ok", scored: scored.length, out: options.out });
+  });
+
+program
+  .command("sync:crm")
+  .description("Dry-run sync scored leads into a CRM target.")
+  .requiredOption("--target <target>", "hubspot|salesforce|pipedrive")
+  .requiredOption("--in <path>", "Path to scored lead JSON array")
+  .action(async (options) => {
+    const target = SyncTargetSchema.parse(options.target);
+    const leads = await readJsonFile(options.in, z.array(ScoredLeadSchema));
+    const result = await syncProvider.sync(target, leads);
+    printOutput({ status: "ok", ...result });
+  });
+
+program
+  .command("sync:outreach")
+  .description("Dry-run sync scored leads into an outreach platform.")
+  .requiredOption("--target <target>", "apollo|instantly|outreach")
+  .requiredOption("--in <path>", "Path to scored lead JSON array")
+  .action(async (options) => {
+    const target = SyncTargetSchema.parse(options.target);
+    const leads = await readJsonFile(options.in, z.array(ScoredLeadSchema));
+    const result = await syncProvider.sync(target, leads);
+    printOutput({ status: "ok", ...result });
+  });
+
+program.parseAsync(process.argv).catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  process.stderr.write(`${message}\n`);
+  process.exitCode = 1;
+});

package/src/domain.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+export const IcpSchema = z.object({
+  name: z.string().min(1),
+  industries: z.array(z.string().min(1)).default([]),
+  companySizes: z.array(z.string().min(1)).default([]),
+  regions: z.array(z.string().min(1)).default([]),
+  titles: z.array(z.string().min(1)).default([]),
+  pains: z.array(z.string().min(1)).default([]),
+  requiredSignals: z.array(z.string().min(1)).default([]),
+  excludedSignals: z.array(z.string().min(1)).default([]),
+});
+
+export type Icp = z.infer<typeof IcpSchema>;
+
+export const LeadSchema = z.object({
+  companyName: z.string().min(1),
+  domain: z.string().min(1),
+  industry: z.string().min(1),
+  region: z.string().min(1),
+  employeeCount: z.number().int().nonnegative(),
+  contactName: z.string().min(1),
+  title: z.string().min(1),
+  email: z.string().email(),
+  source: z.string().min(1),
+  signals: z.array(z.string().min(1)).default([]),
+});
+
+export type Lead = z.infer<typeof LeadSchema>;
+
+export const EnrichedLeadSchema = LeadSchema.extend({
+  techStack: z.array(z.string().min(1)).default([]),
+  crmFit: z.enum(["high", "medium", "low"]),
+  outreachFit: z.enum(["high", "medium", "low"]),
+  buyingStage: z.enum(["problem-aware", "solution-aware", "active-evaluation"]),
+  notes: z.array(z.string().min(1)).default([]),
+});
+
+export type EnrichedLead = z.infer<typeof EnrichedLeadSchema>;
+
+export const ScoredLeadSchema = EnrichedLeadSchema.extend({
+  score: z.number().int().min(0).max(100),
+  grade: z.enum(["A", "B", "C", "D"]),
+  rationale: z.array(z.string().min(1)).default([]),
+});
+
+export type ScoredLead = z.infer<typeof ScoredLeadSchema>;
+
+export const SyncTargetSchema = z.enum(["hubspot", "salesforce", "pipedrive", "apollo", "instantly", "outreach"]);
+export type SyncTarget = z.infer<typeof SyncTargetSchema>;

package/src/engine.ts

@@ -0,0 +1,170 @@
+import { z } from "zod";
+import type { EnrichmentProvider, LeadGenerationTarget, LeadProvider, ScoringProvider, SyncProvider } from "./providers.js";
+import type { EnrichedLead, Icp, Lead, ScoredLead, SyncTarget } from "./domain.js";
+import { SAMPLE_COMPANIES, SAMPLE_CONTACTS, SAMPLE_SIGNALS, SAMPLE_TECH } from "./sample-data.js";
+
+function pickByIndex<T>(items: T[], index: number): T {
+  const item = items[index % items.length];
+  if (item === undefined) {
+    throw new Error("sample data invariant violated");
+  }
+  return item;
+}
+
+function normalizeCompanySize(employeeCount: number): string {
+  if (employeeCount < 50) {
+    return "1-49";
+  }
+  if (employeeCount < 200) {
+    return "50-199";
+  }
+  if (employeeCount < 500) {
+    return "200-499";
+  }
+  return "500+";
+}
+
+function deriveCompanyNameFromDomain(domain: string): string {
+  const normalizedDomain = domain
+    .toLowerCase()
+    .replace(/^https?:\/\//, "")
+    .replace(/^www\./, "")
+    .split("/")[0];
+  const hostname = normalizedDomain.split(".")[0] ?? normalizedDomain;
+
+  return hostname
+    .split(/[-_]/)
+    .filter((part) => part.length > 0)
+    .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+    .join(" ");
+}
+
+function buildTargetCompany(target: LeadGenerationTarget, fallback: (typeof SAMPLE_COMPANIES)[number], icp: Icp) {
+  const domain = target.companyDomain?.trim().toLowerCase();
+  if (domain === undefined) {
+    return fallback;
+  }
+
+  return {
+    companyName: target.companyName?.trim() || deriveCompanyNameFromDomain(domain),
+    domain,
+    industry: icp.industries[0] ?? fallback.industry,
+    region: icp.regions[0] ?? fallback.region,
+    employeeCount: fallback.employeeCount
+  };
+}
+
+export class HeuristicLeadProvider implements LeadProvider {
+  async generateLeads(icp: Icp, count: number, target: LeadGenerationTarget = {}): Promise<Lead[]> {
+    return Array.from({ length: count }, (_, index) => {
+      const fallbackCompany = pickByIndex(SAMPLE_COMPANIES, index);
+      const company = buildTargetCompany(target, fallbackCompany, icp);
+      const contact = pickByIndex(SAMPLE_CONTACTS, index + 1);
+      const signals = [pickByIndex(SAMPLE_SIGNALS, index), pickByIndex(SAMPLE_SIGNALS, index + 2)];
+      const industry = icp.industries[index % Math.max(icp.industries.length, 1)] ?? company.industry;
+      const region = icp.regions[index % Math.max(icp.regions.length, 1)] ?? company.region;
+      const title = icp.titles[index % Math.max(icp.titles.length, 1)] ?? contact.title;
+
+      return {
+        companyName: company.companyName,
+        domain: company.domain,
+        industry,
+        region,
+        employeeCount: company.employeeCount,
+        contactName: contact.contactName,
+        title,
+        email: `${contact.contactName.toLowerCase().replaceAll(" ", ".")}@${company.domain}`,
+        source: target.companyDomain ? "heuristic-target-account" : "heuristic-seed",
+        signals
+      };
+    });
+  }
+}
+
+export class HeuristicEnrichmentProvider implements EnrichmentProvider {
+  async enrichLeads(leads: Lead[]): Promise<EnrichedLead[]> {
+    return leads.map((lead, index) => ({
+      ...lead,
+      techStack: [pickByIndex(SAMPLE_TECH, index), pickByIndex(SAMPLE_TECH, index + 3)],
+      crmFit: lead.employeeCount > 200 ? "high" : lead.employeeCount > 100 ? "medium" : "low",
+      outreachFit: lead.signals.some((signal) => signal.includes("outbound")) ? "high" : "medium",
+      buyingStage: lead.signals.some((signal) => signal.includes("funding")) ? "active-evaluation" : "solution-aware",
+      notes: [
+        `${lead.companyName} matches the ${lead.industry} segment.`,
+        `${lead.contactName} is likely close to revenue tooling decisions.`
+      ]
+    }));
+  }
+}
+
+export class HeuristicScoringProvider implements ScoringProvider {
+  async scoreLeads(icp: Icp, leads: EnrichedLead[]): Promise<ScoredLead[]> {
+    return leads.map((lead) => {
+      const rationale: string[] = [];
+      let score = 40;
+
+      if (icp.industries.includes(lead.industry)) {
+        score += 20;
+        rationale.push("Industry matches ICP.");
+      }
+
+      if (icp.regions.includes(lead.region)) {
+        score += 10;
+        rationale.push("Region matches ICP.");
+      }
+
+      const normalizedSize = normalizeCompanySize(lead.employeeCount);
+      if (icp.companySizes.includes(normalizedSize)) {
+        score += 10;
+        rationale.push("Company size matches ICP.");
+      }
+
+      if (icp.titles.includes(lead.title)) {
+        score += 10;
+        rationale.push("Contact title matches ICP.");
+      }
+
+      const requiredMatches = icp.requiredSignals.filter((signal) => lead.signals.includes(signal));
+      score += Math.min(requiredMatches.length * 5, 10);
+      if (requiredMatches.length > 0) {
+        rationale.push(`Matched ${requiredMatches.length} required buying signals.`);
+      }
+
+      const excludedMatches = icp.excludedSignals.filter((signal) => lead.signals.includes(signal));
+      score -= excludedMatches.length * 15;
+      if (excludedMatches.length > 0) {
+        rationale.push(`Matched ${excludedMatches.length} excluded signals.`);
+      }
+
+      if (lead.crmFit === "high") {
+        score += 5;
+        rationale.push("Strong CRM fit.");
+      }
+
+      if (lead.outreachFit === "high") {
+        score += 5;
+        rationale.push("Strong outreach fit.");
+      }
+
+      const clampedScore = z.number().int().min(0).max(100).parse(score);
+      const grade = clampedScore >= 85 ? "A" : clampedScore >= 70 ? "B" : clampedScore >= 55 ? "C" : "D";
+
+      return {
+        ...lead,
+        score: clampedScore,
+        grade,
+        rationale
+      };
+    });
+  }
+}
+
+export class DryRunSyncProvider implements SyncProvider {
+  async sync(target: SyncTarget, leads: ScoredLead[]): Promise<{ target: SyncTarget; synced: number; dryRun: boolean }> {
+    return {
+      target,
+      synced: leads.length,
+      dryRun: true
+    };
+  }
+}

package/src/io.ts

@@ -0,0 +1,21 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+
+export async function readJsonFile<T>(filePath: string, schema: z.ZodType<T>): Promise<T> {
+  const content = await readFile(filePath, "utf8");
+  const parsed = JSON.parse(content) as unknown;
+  return schema.parse(parsed);
+}
+
+export async function writeJsonFile(filePath: string, value: unknown): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function splitCsv(value: string): string[] {
+  return value
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+}

package/src/providers.ts

@@ -0,0 +1,22 @@
+import type { EnrichedLead, Icp, Lead, ScoredLead, SyncTarget } from "./domain.js";
+
+export interface LeadGenerationTarget {
+  companyDomain?: string;
+  companyName?: string;
+}
+
+export interface LeadProvider {
+  generateLeads(icp: Icp, count: number, target?: LeadGenerationTarget): Promise<Lead[]>;
+}
+
+export interface EnrichmentProvider {
+  enrichLeads(leads: Lead[]): Promise<EnrichedLead[]>;
+}
+
+export interface ScoringProvider {
+  scoreLeads(icp: Icp, leads: EnrichedLead[]): Promise<ScoredLead[]>;
+}
+
+export interface SyncProvider {
+  sync(target: SyncTarget, leads: ScoredLead[]): Promise<{ target: SyncTarget; synced: number; dryRun: boolean }>;
+}

package/src/sample-data.ts

@@ -0,0 +1,37 @@
+export const SAMPLE_COMPANIES = [
+  { companyName: "Northstar Freight", domain: "northstarfreight.com", industry: "Logistics", region: "North America", employeeCount: 180 },
+  { companyName: "Brightpath Health", domain: "brightpathhealth.io", industry: "Healthcare", region: "Europe", employeeCount: 320 },
+  { companyName: "ForgeOps Cloud", domain: "forgeopscloud.dev", industry: "Software", region: "North America", employeeCount: 85 },
+  { companyName: "Summit Retail Group", domain: "summitretailgroup.com", industry: "Retail", region: "Europe", employeeCount: 540 },
+  { companyName: "Atlas Industrial", domain: "atlasindustrial.co", industry: "Manufacturing", region: "North America", employeeCount: 260 },
+  { companyName: "Meridian Finance", domain: "meridianfinance.ai", industry: "Financial Services", region: "Europe", employeeCount: 140 }
+];
+
+export const SAMPLE_CONTACTS = [
+  { contactName: "Avery Chen", title: "VP Sales" },
+  { contactName: "Jordan Patel", title: "Head of Revenue Operations" },
+  { contactName: "Taylor Morgan", title: "Director of Growth" },
+  { contactName: "Morgan Diaz", title: "Chief Revenue Officer" },
+  { contactName: "Cameron Lee", title: "Sales Operations Manager" },
+  { contactName: "Riley Brooks", title: "Demand Generation Lead" }
+];
+
+export const SAMPLE_SIGNALS = [
+  "hiring sales reps",
+  "recent funding",
+  "expanding into new regions",
+  "using fragmented sales tooling",
+  "growing outbound team",
+  "launching new product line"
+];
+
+export const SAMPLE_TECH = [
+  "HubSpot",
+  "Salesforce",
+  "Apollo",
+  "Instantly",
+  "Outreach",
+  "Clay",
+  "Segment",
+  "PostHog"
+];