@1dolinski/fastforms 0.1.2 → 0.3.0

package/lib/fill.js

@@ -2,6 +2,14 @@ import { getCustomFact } from "./personas.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+/**
+ * Look up a value from the form persona's facts first, then fall back.
+ * Form persona facts override everything — they're form-specific answers.
+ */
+function formFact(form, key) {
+  return getCustomFact(form, key);
+}
+
 export async function fillByLabel(page, label, value, opts = {}) {
   if (!value) return false;
   return page.evaluate((lbl, val, ta) => {
@@ -55,82 +63,95 @@ export async function clickCheckbox(page, textHint) {
   }, textHint);
 }
 
-export function buildNitroData(user, biz) {
+export function buildNitroData(user, biz, form) {
   const u = user?.profile || {};
   const b = biz?.profile || {};
   const fact = (p, k) => getCustomFact(p, k);
+  const ff = (k) => formFact(form, k);
 
   return {
     fields: [
-      { label: "Company / Project name", value: b.productName || b.companyName || b.name || "" },
-      { label: "Email", value: u.email || "" },
-      { label: "One-line description", value: b.oneLiner || "" },
-      { label: "What are you building", value: b.solution || [b.problem, b.solution].filter(Boolean).join("\n\n"), textarea: true },
-      { label: "Full Name", value: u.fullName || "" },
-      { label: "Role in the company", value: u.currentRole || "" },
-      { label: "X Handle", value: fact(user, "x handle") || fact(user, "twitter") || "" },
-      { label: "LinkedIn username", value: u.linkedIn || "" },
-      { label: "Telegram", value: fact(user, "telegram") || "" },
-      { label: "GitHub username", value: u.github || "" },
-      { label: "Why are you the right founder", value: [u.bio, u.keySkills ? `Key skills: ${u.keySkills}` : "", u.favoriteProjects ? `Notable projects: ${u.favoriteProjects}` : ""].filter(Boolean).join("\n\n"), textarea: true },
-      { label: "video content or long form writing", value: u.portfolio || "", textarea: true },
-      { label: "How did the founders meet", value: fact(user, "founders met") || fact(biz, "founders") || `I'm a solo founder building ${b.productName || b.companyName || "this project"} full-time.`, textarea: true },
-      { label: "Current location of founders", value: u.location || b.location || "" },
-      { label: "how do you plan to spend", value: fact(biz, "spend") || fact(biz, "500k") || "", textarea: true },
-      { label: "What problem are you solving", value: b.problem || "", textarea: true },
-      { label: "closest comparables", value: b.differentiators || "", textarea: true },
-      { label: "Product Link", value: b.website || "" },
-      { label: "What changed in the tech or market", value: fact(biz, "timing") || fact(biz, "why now") || b.rawFacts || "", textarea: true },
-      { label: "Dune Dashboard", value: "" },
-      { label: "Google Analytics", value: "", textarea: true },
-      { label: "target segment", value: b.targetUsers || "", textarea: true },
-      { label: "wedge into the market", value: b.businessModel || b.differentiators || "", textarea: true },
-      { label: "traction have you achieved", value: b.traction || "", textarea: true },
-      { label: "Runway at current burn", value: "12" },
-      { label: "What attracts you the most about Nitro", value: fact(biz, "nitro") || fact(biz, "accelerator") || `The density of high-signal founders and the NYC residency. ${b.productName || "Our product"} is at a stage where concentrated feedback from experienced operators would dramatically accelerate our trajectory.`, textarea: true },
-      { label: "Pick one of the mentors", value: fact(biz, "mentor") || "", textarea: true },
-      { label: "What did you get done last week", value: fact(biz, "last week") || fact(user, "last week") || "", textarea: true },
+      { label: "Company / Project name", value: ff("company") || b.productName || b.companyName || b.name || "" },
+      { label: "Email", value: ff("email") || u.email || "" },
+      { label: "One-line description", value: ff("one-line") || b.oneLiner || "" },
+      { label: "What are you building", value: ff("building") || b.solution || [b.problem, b.solution].filter(Boolean).join("\n\n"), textarea: true },
+      { label: "Full Name", value: ff("full name") || u.fullName || "" },
+      { label: "Role in the company", value: ff("role") || u.currentRole || "" },
+      { label: "X Handle", value: ff("x handle") || fact(user, "x handle") || fact(user, "twitter") || "" },
+      { label: "LinkedIn username", value: ff("linkedin") || u.linkedIn || "" },
+      { label: "Telegram", value: ff("telegram") || fact(user, "telegram") || "" },
+      { label: "GitHub username", value: ff("github") || u.github || "" },
+      { label: "Why are you the right founder", value: ff("right founder") || [u.bio, u.keySkills ? `Key skills: ${u.keySkills}` : "", u.favoriteProjects ? `Notable projects: ${u.favoriteProjects}` : ""].filter(Boolean).join("\n\n"), textarea: true },
+      { label: "video content or long form writing", value: ff("video") || ff("writing") || u.portfolio || "", textarea: true },
+      { label: "How did the founders meet", value: ff("founders meet") || ff("founders met") || fact(user, "founders met") || fact(biz, "founders") || `I'm a solo founder building ${b.productName || b.companyName || "this project"} full-time.`, textarea: true },
+      { label: "Current location of founders", value: ff("location") || u.location || b.location || "" },
+      { label: "how do you plan to spend", value: ff("spend") || ff("500k") || fact(biz, "spend") || fact(biz, "500k") || "", textarea: true },
+      { label: "What problem are you solving", value: ff("problem") || b.problem || "", textarea: true },
+      { label: "closest comparables", value: ff("comparables") || ff("competitors") || b.differentiators || "", textarea: true },
+      { label: "Product Link", value: ff("product link") || b.website || "" },
+      { label: "What changed in the tech or market", value: ff("timing") || ff("why now") || fact(biz, "timing") || fact(biz, "why now") || b.rawFacts || "", textarea: true },
+      { label: "Dune Dashboard", value: ff("dune") || "" },
+      { label: "Google Analytics", value: ff("analytics") || "", textarea: true },
+      { label: "target segment", value: ff("target") || b.targetUsers || "", textarea: true },
+      { label: "wedge into the market", value: ff("wedge") || ff("market") || b.businessModel || b.differentiators || "", textarea: true },
+      { label: "traction have you achieved", value: ff("traction") || b.traction || "", textarea: true },
+      { label: "Runway at current burn", value: ff("runway") || "12" },
+      { label: "What attracts you the most about Nitro", value: ff("attracts") || ff("nitro") || fact(biz, "nitro") || fact(biz, "accelerator") || `The density of high-signal founders and the NYC residency. ${b.productName || "Our product"} is at a stage where concentrated feedback from experienced operators would dramatically accelerate our trajectory.`, textarea: true },
+      { label: "Pick one of the mentors", value: ff("mentor") || fact(biz, "mentor") || "", textarea: true },
+      { label: "What did you get done last week", value: ff("last week") || fact(biz, "last week") || fact(user, "last week") || "", textarea: true },
     ],
     radios: [
-      { section: "committed full-time", value: "yes" },
-      { section: "raised funding before", value: "no" },
-      { section: "currently fundraising", value: "yes" },
-      { section: "exclusively in Nitro", value: "yes" },
-      { section: "attend the full 1-month NYC", value: "yes" },
+      { section: "committed full-time", value: ff("full-time") || "yes" },
+      { section: "raised funding before", value: ff("raised funding") || "no" },
+      { section: "currently fundraising", value: ff("fundraising") || "yes" },
+      { section: "exclusively in Nitro", value: ff("exclusively") || "yes" },
+      { section: "attend the full 1-month NYC", value: ff("attend") || "yes" },
     ],
     checkboxes: ["MVP / demo exists"],
   };
 }
 
-export async function genericFill(page, user, biz) {
+export async function genericFill(page, user, biz, form) {
   const u = user?.profile || {};
   const b = biz?.profile || {};
   const fact = (p, k) => getCustomFact(p, k);
+  const ff = (k) => formFact(form, k);
 
   const fieldMap = [
-    { hints: ["company", "project name", "organization"], value: b.productName || b.companyName || b.name || "" },
-    { hints: ["email"], value: u.email || "" },
-    { hints: ["full name", "your name", "first name"], value: u.fullName || "" },
-    { hints: ["one-line", "one liner", "tagline", "short description"], value: b.oneLiner || "" },
-    { hints: ["what are you building", "describe your product", "about your project"], value: b.solution || "", textarea: true },
-    { hints: ["role", "title", "position"], value: u.currentRole || "" },
-    { hints: ["x handle", "twitter"], value: fact(user, "x handle") || fact(user, "twitter") || "" },
-    { hints: ["linkedin"], value: u.linkedIn || "" },
-    { hints: ["telegram"], value: fact(user, "telegram") || "" },
-    { hints: ["github"], value: u.github || "" },
-    { hints: ["website", "url", "product link"], value: b.website || u.portfolio || "" },
-    { hints: ["phone", "tel"], value: u.phone || "" },
-    { hints: ["location", "city", "where are you based"], value: u.location || b.location || "" },
-    { hints: ["bio", "about yourself", "tell us about you"], value: u.bio || "", textarea: true },
-    { hints: ["problem", "what problem"], value: b.problem || "", textarea: true },
-    { hints: ["solution", "how does it work"], value: b.solution || "", textarea: true },
-    { hints: ["traction", "progress", "metrics"], value: b.traction || "", textarea: true },
-    { hints: ["target", "customer", "user"], value: b.targetUsers || "", textarea: true },
-    { hints: ["business model", "revenue", "monetiz"], value: b.businessModel || "", textarea: true },
-    { hints: ["differentiator", "competitive", "unique"], value: b.differentiators || "", textarea: true },
-    { hints: ["why you", "right founder", "why are you"], value: u.bio || "", textarea: true },
+    { hints: ["company", "project name", "organization"], value: ff("company") || b.productName || b.companyName || b.name || "" },
+    { hints: ["email"], value: ff("email") || u.email || "" },
+    { hints: ["full name", "your name", "first name"], value: ff("full name") || u.fullName || "" },
+    { hints: ["one-line", "one liner", "tagline", "short description"], value: ff("one-liner") || b.oneLiner || "" },
+    { hints: ["what are you building", "describe your product", "about your project"], value: ff("building") || b.solution || "", textarea: true },
+    { hints: ["role", "title", "position"], value: ff("role") || u.currentRole || "" },
+    { hints: ["x handle", "twitter"], value: ff("x handle") || fact(user, "x handle") || fact(user, "twitter") || "" },
+    { hints: ["linkedin"], value: ff("linkedin") || u.linkedIn || "" },
+    { hints: ["telegram"], value: ff("telegram") || fact(user, "telegram") || "" },
+    { hints: ["github"], value: ff("github") || u.github || "" },
+    { hints: ["website", "url", "product link"], value: ff("website") || b.website || u.portfolio || "" },
+    { hints: ["phone", "tel"], value: ff("phone") || u.phone || "" },
+    { hints: ["location", "city", "where are you based"], value: ff("location") || u.location || b.location || "" },
+    { hints: ["bio", "about yourself", "tell us about you"], value: ff("bio") || u.bio || "", textarea: true },
+    { hints: ["problem", "what problem"], value: ff("problem") || b.problem || "", textarea: true },
+    { hints: ["solution", "how does it work"], value: ff("solution") || b.solution || "", textarea: true },
+    { hints: ["traction", "progress", "metrics"], value: ff("traction") || b.traction || "", textarea: true },
+    { hints: ["target", "customer", "user"], value: ff("target") || b.targetUsers || "", textarea: true },
+    { hints: ["business model", "revenue", "monetiz"], value: ff("business model") || b.businessModel || "", textarea: true },
+    { hints: ["differentiator", "competitive", "unique"], value: ff("differentiator") || b.differentiators || "", textarea: true },
+    { hints: ["why you", "right founder", "why are you"], value: ff("right founder") || u.bio || "", textarea: true },
   ];
 
+  // Append any form persona facts that don't already map to standard fields
+  if (form?.customFacts?.length) {
+    const usedKeys = new Set(fieldMap.flatMap((f) => f.hints));
+    for (const cf of form.customFacts) {
+      if (!cf.enabled || !cf.value) continue;
+      const keyLower = cf.key.toLowerCase();
+      if ([...usedKeys].some((h) => keyLower.includes(h) || h.includes(keyLower))) continue;
+      fieldMap.push({ hints: [cf.key], value: cf.value, textarea: cf.value.length > 100 });
+    }
+  }
+
   let filled = 0, skipped = 0;
   for (const f of fieldMap) {
     if (!f.value) { skipped++; continue; }
@@ -146,12 +167,16 @@ export async function genericFill(page, user, biz) {
   return { filled, skipped };
 }
 
-export async function fillForm(page, formUrl, user, biz) {
+export async function fillForm(page, formUrl, user, biz, form) {
   console.log(`\n  Filling form...\n`);
+  if (form) {
+    const fp = form.profile || {};
+    if (fp.organization) console.log(`  Form: ${fp.organization}${fp.purpose ? ` — ${fp.purpose}` : ""}`);
+  }
   await sleep(2000);
 
   if (formUrl.includes("nitroacc.xyz")) {
-    const data = buildNitroData(user, biz);
+    const data = buildNitroData(user, biz, form);
     let filled = 0, skipped = 0;
 
     for (const f of data.fields) {
@@ -180,7 +205,7 @@ export async function fillForm(page, formUrl, user, biz) {
 
     console.log(`\n  Filled ${filled}, skipped ${skipped} (empty persona fields).`);
   } else {
-    const { filled, skipped } = await genericFill(page, user, biz);
+    const { filled, skipped } = await genericFill(page, user, biz, form);
     console.log(`\n  Filled ${filled}, skipped ${skipped} (empty or no match).`);
   }
 

package/lib/local.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from "fs";
+import { join, basename } from "path";
 import { homedir } from "os";
 
 export function findFastformsDir() {
@@ -25,10 +25,15 @@ function writeJson(path, data) {
   writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
 }
 
-/**
- * Normalize flat local format into the shape fill.js expects:
- *   { name, profile: { ...fields }, customFacts: [...] }
- */
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "default";
+}
+
+// ---------------------------------------------------------------------------
+// Normalize flat local format → shape fill.js expects:
+//   { name, profile: { ...fields }, customFacts: [...] }
+// ---------------------------------------------------------------------------
+
 function normalizeUser(raw) {
   if (!raw) return null;
   const { name, facts, ...rest } = raw;
@@ -82,6 +87,23 @@ function normalizeBusiness(raw) {
   };
 }
 
+function normalizeForm(raw) {
+  if (!raw) return null;
+  const { name, facts, urls, ...rest } = raw;
+  return {
+    name: name || "unknown form",
+    urls: urls || (rest.url ? [rest.url] : []),
+    profile: {
+      organization: rest.organization || rest.org || name || "",
+      purpose: rest.purpose || "",
+      notes: rest.notes || "",
+      deadline: rest.deadline || "",
+      requirements: rest.requirements || "",
+    },
+    customFacts: factsToArray(facts),
+  };
+}
+
 function factsToArray(facts) {
   if (!facts || typeof facts !== "object") return [];
   return Object.entries(facts).map(([key, value], i) => ({
@@ -92,29 +114,92 @@ function factsToArray(facts) {
   }));
 }
 
+// ---------------------------------------------------------------------------
+// Multi-persona loading: reads users/ and businesses/ subdirs.
+// Falls back to legacy user.json / business.json for backward compat.
+// ---------------------------------------------------------------------------
+
+function loadDir(dir, normalizer) {
+  if (!existsSync(dir)) return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort();
+  return files.map((f) => normalizer(readJson(join(dir, f)))).filter(Boolean);
+}
+
 export function loadLocalPersonas(dir) {
-  const userPath = join(dir, "user.json");
-  const bizPath = join(dir, "business.json");
+  const usersDir = join(dir, "users");
+  const bizDir = join(dir, "businesses");
 
-  const rawUser = readJson(userPath);
-  const rawBiz = readJson(bizPath);
+  let personas = loadDir(usersDir, normalizeUser);
+  let businessPersonas = loadDir(bizDir, normalizeBusiness);
 
-  const personas = rawUser ? [normalizeUser(rawUser)] : [];
-  const businessPersonas = rawBiz ? [normalizeBusiness(rawBiz)] : [];
+  // Backward compat: if subdirs are empty, check legacy single files
+  if (!personas.length) {
+    const legacy = readJson(join(dir, "user.json"));
+    if (legacy) personas = [normalizeUser(legacy)];
+  }
+  if (!businessPersonas.length) {
+    const legacy = readJson(join(dir, "business.json"));
+    if (legacy) businessPersonas = [normalizeBusiness(legacy)];
+  }
 
-  return { personas, businessPersonas };
+  const formPersonas = loadDir(join(dir, "forms"), normalizeForm);
+
+  return { personas, businessPersonas, formPersonas };
 }
 
+// ---------------------------------------------------------------------------
+// Save personas into named files under users/ or businesses/
+// ---------------------------------------------------------------------------
+
 export function saveUserPersona(dir, data) {
-  ensureDir(dir);
-  writeJson(join(dir, "user.json"), data);
+  const subdir = ensureDir(join(dir, "users"));
+  const slug = slugify(data.name || "default");
+  writeJson(join(subdir, `${slug}.json`), data);
+  return slug;
 }
 
 export function saveBusinessPersona(dir, data) {
-  ensureDir(dir);
-  writeJson(join(dir, "business.json"), data);
+  const subdir = ensureDir(join(dir, "businesses"));
+  const slug = slugify(data.name || "default");
+  writeJson(join(subdir, `${slug}.json`), data);
+  return slug;
 }
 
+export function saveFormPersona(dir, data) {
+  const subdir = ensureDir(join(dir, "forms"));
+  const slug = slugify(data.name || "form");
+  writeJson(join(subdir, `${slug}.json`), data);
+  return slug;
+}
+
+const TYPE_DIRS = { user: "users", business: "businesses", form: "forms" };
+
+export function deletePersonaFile(dir, type, slug) {
+  const subdir = TYPE_DIRS[type] || type;
+  const path = join(dir, subdir, `${slug}.json`);
+  if (existsSync(path)) unlinkSync(path);
+}
+
+// ---------------------------------------------------------------------------
+// List raw persona files (for edit/delete commands)
+// ---------------------------------------------------------------------------
+
+export function listPersonaFiles(dir, type) {
+  const subdir = join(dir, TYPE_DIRS[type] || type);
+  if (!existsSync(subdir)) return [];
+  return readdirSync(subdir)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      const data = readJson(join(subdir, f));
+      return { slug: basename(f, ".json"), file: f, data };
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
 export function loadDefaults(dir) {
   return readJson(join(dir, "defaults.json")) || {};
 }
@@ -124,6 +209,10 @@ export function saveDefaults(dir, patch) {
   writeJson(join(dir, "defaults.json"), { ...current, ...patch });
 }
 
+// ---------------------------------------------------------------------------
+// Templates
+// ---------------------------------------------------------------------------
+
 export function userTemplate() {
   return {
     name: "",
@@ -154,3 +243,16 @@ export function businessTemplate() {
     facts: {},
   };
 }
+
+export function formTemplate() {
+  return {
+    name: "",
+    urls: [],
+    organization: "",
+    purpose: "",
+    notes: "",
+    deadline: "",
+    requirements: "",
+    facts: {},
+  };
+}

package/lib/personas.js

@@ -92,7 +92,7 @@ function printPersonaSummary(label, persona, profileKeys) {
   if (facts.length) console.log(`    Custom facts: ${facts.length}`);
 }
 
-export function showPersonaDetails(user, biz) {
+export function showPersonaDetails(user, biz, form) {
   printPersonaSummary("User persona", user, [
     ["fullName", "Name"],
     ["email", "Email"],
@@ -108,36 +108,113 @@ export function showPersonaDetails(user, biz) {
     ["website", "Website"],
     ["category", "Category"],
   ]);
+  if (form) {
+    console.log(`\n  Form persona: ${form.name}`);
+    const fp = form.profile || {};
+    if (fp.organization) console.log(`    Organization: ${fp.organization}`);
+    if (fp.purpose) console.log(`    Purpose: ${fp.purpose}`);
+    if (fp.deadline) console.log(`    Deadline: ${fp.deadline}`);
+    if (fp.notes) console.log(`    Notes: ${String(fp.notes).slice(0, 80)}${String(fp.notes).length > 80 ? "..." : ""}`);
+    const facts = (form.customFacts || []).filter((f) => f.enabled !== false && f.value);
+    if (facts.length) console.log(`    Form-specific answers: ${facts.length}`);
+  }
 }
 
-export async function selectPersonas(dump, userHint, bizHint) {
-  const config = loadConfig();
-  const personas = dump.personas || [];
-  const bizPersonas = dump.businessPersonas || [];
+// ---------------------------------------------------------------------------
+// Interactive persona selection — supports multiple personas from any source
+// ---------------------------------------------------------------------------
 
-  // Use defaults if no hint and defaults are saved
-  const effectiveUserHint = userHint || config.defaultUser || "";
-  const effectiveBizHint = bizHint || config.defaultBusiness || "";
+async function pickFromList(label, list, hint, keys, defaultName) {
+  if (!list?.length) return null;
+  if (list.length === 1) return list[0];
 
-  let user = pickPersona(personas, effectiveUserHint, ["name", "profile.fullName"]);
-  let biz = pickPersona(bizPersonas, effectiveBizHint, ["name", "profile.companyName", "profile.productName"]);
+  // Try hint-based match
+  if (hint) {
+    const match = pickPersona(list, hint, keys);
+    if (match) return match;
+  }
 
-  // Interactive selection if multiple and no effective hint
-  if (!effectiveUserHint && personas.length > 1) {
-    console.log("\n  User personas:\n");
-    personas.forEach((p, i) => console.log(`    ${i + 1}. ${p.name} (${p.profile?.fullName || "?"})`));
-    const ans = await ask(`\n  Pick user persona [1-${personas.length}]: `);
-    const idx = Number(ans) - 1;
-    if (idx >= 0 && idx < personas.length) user = personas[idx];
+  // Try default
+  if (defaultName) {
+    const match = list.find((p) => p.name === defaultName);
+    if (match) return match;
   }
 
-  if (!effectiveBizHint && bizPersonas.length > 1) {
-    console.log("\n  Business personas:\n");
-    bizPersonas.forEach((p, i) => console.log(`    ${i + 1}. ${p.name} (${p.profile?.companyName || "?"})`));
-    const ans = await ask(`\n  Pick business persona [1-${bizPersonas.length}]: `);
-    const idx = Number(ans) - 1;
-    if (idx >= 0 && idx < bizPersonas.length) biz = bizPersonas[idx];
+  // Interactive selection
+  console.log(`\n  ${label}:\n`);
+  list.forEach((p, i) => {
+    const detail = keys.map((k) => k.split(".").reduce((o, s) => o?.[s], p)).filter(Boolean)[0] || "";
+    console.log(`    ${i + 1}. ${p.name}${detail ? ` (${detail})` : ""}`);
+  });
+  const ans = await ask(`\n  Pick ${label.toLowerCase()} [1-${list.length}]: `);
+  const idx = Number(ans) - 1;
+  if (idx >= 0 && idx < list.length) return list[idx];
+  return list[0];
+}
+
+export function matchFormByUrl(formPersonas, targetUrl) {
+  if (!formPersonas?.length || !targetUrl) return null;
+  const lower = targetUrl.toLowerCase();
+  for (const fp of formPersonas) {
+    for (const u of (fp.urls || [])) {
+      if (u && lower.includes(u.toLowerCase())) return fp;
+    }
+    const orgSlug = (fp.name || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (orgSlug && lower.includes(orgSlug)) return fp;
   }
+  return null;
+}
+
+export async function selectFormPersona(formPersonas, targetUrl) {
+  if (!formPersonas?.length) return null;
+
+  // Auto-match by URL
+  const autoMatch = matchFormByUrl(formPersonas, targetUrl);
+  if (autoMatch) {
+    console.log(`  Auto-matched form persona: ${autoMatch.name}`);
+    return autoMatch;
+  }
+
+  if (formPersonas.length === 1) return formPersonas[0];
+
+  // Interactive
+  console.log(`\n  Form personas:\n`);
+  formPersonas.forEach((f, i) => {
+    const org = f.profile?.organization || "";
+    console.log(`    ${i + 1}. ${f.name}${org ? ` (${org})` : ""}`);
+  });
+  console.log(`    ${formPersonas.length + 1}. (none — skip form persona)`);
+  const ans = await ask(`\n  Pick form persona [1-${formPersonas.length + 1}]: `);
+  const idx = Number(ans) - 1;
+  if (idx >= 0 && idx < formPersonas.length) return formPersonas[idx];
+  return null;
+}
+
+export async function selectPersonas(dump, userHint, bizHint) {
+  const config = loadConfig();
+  const personas = dump.personas || [];
+  const bizPersonas = dump.businessPersonas || [];
+
+  const effectiveUserHint = userHint || "";
+  const effectiveBizHint = bizHint || "";
+  const defaultUser = config.defaultUser || "";
+  const defaultBiz = config.defaultBusiness || "";
+
+  const user = await pickFromList(
+    "User personas",
+    personas,
+    effectiveUserHint,
+    ["name", "profile.fullName"],
+    defaultUser,
+  );
+
+  const biz = await pickFromList(
+    "Business personas",
+    bizPersonas,
+    effectiveBizHint,
+    ["name", "profile.companyName", "profile.productName"],
+    defaultBiz,
+  );
 
   return { user, biz };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1dolinski/fastforms",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Fill any form fast. Manage personas on the web, fill forms from your terminal.",
   "type": "module",
   "bin": {