salesprompter-cli 0.1.0 → 0.1.1

package/src/engine.ts

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

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

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

@@ -1,37 +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/tests/cli.test.ts

@@ -1,184 +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: string[]): Promise<unknown> {
-  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 as { status: string }).status, "ok");
-
-    const generateResult = await runCli([
-      "leads:generate",
-      "--icp",
-      icpPath,
-      "--count",
-      "4",
-      "--out",
-      leadsPath
-    ]);
-
-    assert.equal((generateResult as { generated: number }).generated, 4);
-
-    const enrichResult = await runCli([
-      "leads:enrich",
-      "--in",
-      leadsPath,
-      "--out",
-      enrichedPath
-    ]);
-
-    assert.equal((enrichResult as { enriched: number }).enriched, 4);
-
-    const scoreResult = await runCli([
-      "leads:score",
-      "--icp",
-      icpPath,
-      "--in",
-      enrichedPath,
-      "--out",
-      scoredPath
-    ]);
-
-    assert.equal((scoreResult as { scored: number }).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")) as Array<{
-      score: number;
-      grade: string;
-      rationale: string[];
-      crmFit: string;
-      outreachFit: string;
-    }>;
-
-    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")) as Array<{
-      companyName: string;
-      domain: string;
-      email: string;
-      source: string;
-    }>;
-
-    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/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "strict": true,
-    "rootDir": "src",
-    "outDir": "dist",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*.ts"]
-}

package/tsconfig.test.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "outDir": "dist-tests"
-  },
-  "include": ["src/**/*.ts", "tests/**/*.ts"]
-}