salesprompter-cli 0.1.0 → 0.1.1

package/dist-tests/src/engine.js

@@ -1,147 +0,0 @@
-import { z } from "zod";
-import { SAMPLE_COMPANIES, SAMPLE_CONTACTS, SAMPLE_SIGNALS, SAMPLE_TECH } from "./sample-data.js";
-function pickByIndex(items, index) {
-    const item = items[index % items.length];
-    if (item === undefined) {
-        throw new Error("sample data invariant violated");
-    }
-    return item;
-}
-function normalizeCompanySize(employeeCount) {
-    if (employeeCount < 50) {
-        return "1-49";
-    }
-    if (employeeCount < 200) {
-        return "50-199";
-    }
-    if (employeeCount < 500) {
-        return "200-499";
-    }
-    return "500+";
-}
-function deriveCompanyNameFromDomain(domain) {
-    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, fallback, 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 {
-    async generateLeads(icp, count, target = {}) {
-        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 {
-    async enrichLeads(leads) {
-        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 {
-    async scoreLeads(icp, leads) {
-        return leads.map((lead) => {
-            const rationale = [];
-            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 {
-    async sync(target, leads) {
-        return {
-            target,
-            synced: leads.length,
-            dryRun: true
-        };
-    }
-}

package/dist-tests/src/io.js

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

package/dist-tests/src/providers.js

@@ -1 +0,0 @@
-export {};

package/dist-tests/src/sample-data.js

@@ -1,34 +0,0 @@
-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"
-];

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

@@ -1,149 +0,0 @@
-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/src/cli.ts

@@ -1,136 +0,0 @@
-#!/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

@@ -1,50 +0,0 @@
-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>;