create-venture 0.1.1 → 0.2.0

package/index.mjs

@@ -1,15 +1,26 @@
 #!/usr/bin/env node
-// create-venture: Naive's generator, the way create-next-app is Next.js's (I-1, I-3, I-7). It asks for a
-// name, offers the recommended defaults or lets you customize them, creates the venture in a new or
-// empty directory, installs the framework with your package manager, and initializes git.
+// create-venture: Naive's generator, the way create-next-app is Next.js's (I-1, I-3, I-7, EE-082). Before
+// anything is scaffolded it asks what you are building (described in a few words and classified by a
+// model, or picked from the list) and what role you hold, then who else is founding it, the phase, and
+// which functions (hats) each person owns. The venture type decides the packages and first decisions:
+// a VC fund starts with a thesis and terms, a software startup with its product questions.
 //
-//   npx create-venture [dir] [--yes] [--phase <phase>] [--layers a,b] [--legal-form <form>] [--dump <file>]
+//   npx create-venture [dir] [--yes] [--type <type> | --describe "<a few words>"] [--role <role>]
+//                      [--name "<your name>"] [--team "<name>, <name>"] [--phase <phase>]
+//                      [--source <function>=<system>[:<address>],... ...] [--rho-fixture]
+//                      [--layers a,b] [--legal-form <form>] [--dump <file>]
 //                      [--use-npm | --use-pnpm | --use-yarn | --use-bun] [--skip-install] [--no-git]
 //                      [--framework <spec>] [--reset-preferences]
 //
-// --yes takes the recommended defaults: the discovery phase, the phase's packages, checks on, and
-// AGENTS.md. Answers to the setup questions are kept
-// in ~/.config/naive/create-venture.json, so the next venture can reuse them.
+// --source says where a function keeps its truth (schema/systems-catalog.json), recorded as pointers in
+// knowledge/sources.json: --source products=local-repo:../app,github:acme/app,vercel:acme/app
+// --source finance=rho. Rho is synced at setup: its sandbox, the founder's own with RHO_API_TOKEN, or a
+// saved answer with --rho-fixture (offline; recorded as a fixture).
+//
+// --yes takes the recommended defaults: a software startup, you as its solo founder wearing every hat,
+// the discovery phase, the type's packages, checks on, and AGENTS.md. --describe classifies only when
+// TYPESAFE_API_KEY is set; otherwise pick with --type. Answers are kept in
+// ~/.config/naive/create-venture.json, so the next venture can reuse them.
 
 import { spawnSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -30,11 +41,13 @@ const fw = JSON.parse(readFileSync(join(framework, "package.json"), "utf8"));
 const { layers: PHASE_LAYERS } = JSON.parse(readFileSync(join(framework, "schema/scaffold/defaults.json"), "utf8"));
 const PHASES = Object.keys(PHASE_LAYERS);
 const LAYERS = ["purpose", "knowledge", "operations", "evidence", "governance", "interface"];
+// The legal forms venture.json accepts, from its schema, so the question can only offer valid answers.
+const FORMS = JSON.parse(readFileSync(join(framework, "schema/venture.schema.json"), "utf8")).properties.form.properties.legal_form.enum;
 
 const argv = process.argv.slice(2);
 const opt = (n) => { const i = argv.indexOf(`--${n}`); return i >= 0 ? argv[i + 1] : undefined; };
 const flag = (n) => argv.includes(`--${n}`);
-const valued = new Set(["phase", "layers", "legal-form", "dump", "framework"]);
+const valued = new Set(["phase", "layers", "legal-form", "dump", "framework", "type", "describe", "role", "name", "team"]);
 const positional = argv.filter((a, i) => !a.startsWith("--") && !(i > 0 && valued.has(argv[i - 1].slice(2))));
 const bold = (s) => (process.stdout.isTTY ? `\x1b[1m${s}\x1b[22m` : s);
 const cyan = (s) => (process.stdout.isTTY ? `\x1b[36m${s}\x1b[39m` : s);
@@ -73,20 +86,111 @@ const id = slug(basename(dir));
 if (!id) fail(`${basename(dir)} has no letters or digits to make a venture id from`);
 if (existsSync(dir) && readdirSync(dir).length) fail(`${dir} already exists and is not empty. create-venture only creates new ventures; to bring an existing project in, create one here and run naive port or naive migrate.`);
 
-// 2. Defaults, the last venture's answers, or your own (I-3, I-7).
+// The framework's registries: venture types, roles and functions (EE-082).
+const { types: TYPES, roles: ROLES, classify, canClassify } = await import(join(framework, "schema/venture-type.mjs")).then((m) => ({ types: m.types(), roles: m.roles(), classify: m.classify, canClassify: m.canClassify }));
+const DEPARTMENTS = JSON.parse(readFileSync(join(framework, "operations/departments.json"), "utf8")).departments;
+const deptLabel = (d) => DEPARTMENTS.find((x) => x.id === d)?.label ?? d;
+const roleOf = (r) => ROLES.find((x) => x.id === r);
+const gitName = () => spawnSync("git", ["config", "user.name"], { encoding: "utf8" }).stdout?.trim() || null;
+
+// 2. What you are building: in a few words for the model, or from the list. Nothing is scaffolded until it is set.
+let vtype = opt("type") ? TYPES.find((t) => t.id === opt("type")) : null;
+if (opt("type") && !vtype) fail(`unknown venture type ${opt("type")}: one of ${TYPES.map((t) => t.id).join(", ")}`);
+const pickFromList = async () => {
+  TYPES.forEach((t, i) => console.log(`  ${String(i + 1).padStart(2)}. ${t.label}: ${t.description}`));
+  const a = await ask("Which kind of venture is it? (number or id)", "1");
+  const t = TYPES[Number(a) - 1] ?? TYPES.find((x) => x.id === a);
+  if (!t) { console.log("  choose a number from the list"); if (piped && !piped.length) fail("no answer left to choose with"); return pickFromList(); }
+  return t;
+};
+const classified = async (words) => {
+  if (!canClassify()) { console.log("  (no TYPESAFE_API_KEY, so pick from the list)"); return null; }
+  try {
+    const c = classify(words);
+    if (c.uncertain) { console.log(`  not sure what kind of venture that is (best guess ${c.ranked[0].label}, ${Math.round(c.ranked[0].p * 100)}%), so pick from the list`); return null; }
+    return TYPES.find((t) => t.id === c.best.id);
+  } catch (e) { console.log(`  ${e.message}; pick from the list`); return null; }
+};
+if (!vtype && opt("describe")) {
+  vtype = await classified(opt("describe"));
+  if (!vtype && !interactive) fail(`could not classify "${opt("describe")}": pass --type, one of ${TYPES.map((t) => t.id).join(", ")}`);
+  if (vtype) console.log(`  ${opt("describe")}: a ${vtype.label.toLowerCase()}`);
+}
+if (!vtype && interactive) {
+  const words = await ask("What are you building? Describe it in a few words, or press Enter to pick from the list", "");
+  if (words) {
+    const t = await classified(words);
+    if (t && (await choose(`That sounds like a ${t.label.toLowerCase()}. Is that right?`, ["yes", "no"], "yes")) === "yes") vtype = t;
+  }
+  if (!vtype) vtype = await pickFromList();
+}
+// --yes with no type: the recommended default, a software startup.
+if (!vtype) vtype = TYPES.find((t) => t.id === "software-startup");
+
+// 3. Your role in it, from the roles this type has. Investors are a role too: a general partner runs a fund.
+let role = opt("role") ?? (interactive ? await choose("What is your role in it?", vtype.roles, vtype.default_role) : vtype.default_role);
+if (!vtype.roles.includes(role)) fail(`a ${vtype.label.toLowerCase()} has no ${role} role: one of ${vtype.roles.join(", ")}`);
+
+// 4. You, and whether you are building it solo or with a team.
+const me = opt("name") ?? (interactive ? await ask("What is your name?", gitName() ?? "Founder") : gitName() ?? "Founder");
+let others = opt("team") ? opt("team").split(",").map((x) => x.trim()).filter(Boolean) : [];
+if (!opt("team") && interactive && (await choose("Are you building it solo or with a team?", ["solo", "team"], prefs?.mode ?? "solo")) === "team") {
+  others = (await ask("Who else is founding it? (names, comma separated)", "")).split(",").map((x) => x.trim()).filter(Boolean);
+  if (!others.length) console.log("  no other names, so you are building it solo");
+}
+const mode = others.length ? "team" : "solo";
+const coRole = vtype.id === "vc-fund" ? "general-partner" : "co-founder";
+const people = [{ id: slug(me) || "founder", name: me, role }, ...others.map((n) => ({ id: slug(n), name: n, role: coRole }))];
+if (new Set(people.map((p) => p.id)).size !== people.length) fail("two people would have the same id; give each a distinct name");
+
+// 5. The phase, the hats, and the rest of the defaults (I-3, I-7).
 const recommended = { phase: "discovery", layers: null, legalForm: null, dump: null };
 let answers = { ...recommended };
 const given = opt("phase") || opt("layers") || opt("legal-form") || opt("dump");
 if (given) answers = { phase: opt("phase") ?? "discovery", layers: opt("layers") ?? null, legalForm: opt("legal-form") ?? null, dump: opt("dump") ?? null };
-else if (interactive) {
+else if (interactive) answers.phase = await choose("Which phase is the venture in?", PHASES, prefs?.phase ?? "discovery");
+// A solo founder owns every function the type imports; on a team, each function is asked once.
+const owners = people.filter((p) => roleOf(p.role)?.owns_when_solo);
+for (const p of people) p.hats = [];
+if (owners.length === 1 || !interactive) for (const d of vtype.departments) (owners[0] ?? { hats: [] }).hats.push(d);
+else for (const d of vtype.departments) {
+  const who = await choose(`Who owns ${deptLabel(d)}?`, owners.map((p) => p.id), owners[0].id);
+  owners.find((p) => p.id === who).hats.push(d);
+}
+// 6. Where each function keeps its truth (EE-083): pointers to its systems of record, in the founder's words when none fits.
+const CATALOG = JSON.parse(readFileSync(join(framework, "schema/systems-catalog.json"), "utf8"));
+const asked = [...vtype.departments.filter((d) => CATALOG.functions[d]), "legal"];
+const parseSystems = (text) => {
+  const items = text.split(",").map((x) => x.trim()).filter(Boolean);
+  const systems = items.map((x) => { const i = x.indexOf(":"); const sys = i < 0 ? x : x.slice(0, i); return CATALOG.systems[sys] ? { system: sys, ...(i < 0 ? {} : { address: x.slice(i + 1) }) } : null; });
+  return systems.every(Boolean) ? { systems } : { systems: [], note: text.trim() };
+};
+const functions = {};
+const sourceFlags = argv.flatMap((a, i) => (a === "--source" ? [argv[i + 1]] : []));
+for (const f of sourceFlags) {
+  const [fn, ...rest] = f.split("=");
+  if (!CATALOG.functions[fn]) fail(`--source ${f}: ${fn} is not a function systems are kept for (${Object.keys(CATALOG.functions).join(", ")})`);
+  functions[fn] = parseSystems(rest.join("="));
+  for (const s of functions[fn].systems) if (!CATALOG.functions[fn].includes(s.system)) fail(`--source ${f}: ${s.system} is not offered for ${fn} (${CATALOG.functions[fn].join(", ")})`);
+}
+if (interactive && !sourceFlags.length) {
+  console.log("\nNow point Naive at where each function keeps its truth. Name systems (comma separated, add :address if you know it), type none, or say it in your own words.");
+  for (const fn of asked) {
+    const options = CATALOG.functions[fn];
+    const a = await ask(`Where is the source of truth for ${fn === "legal" ? "legal documents" : deptLabel(fn)}? ${options.join(" / ")} / none`, "none");
+    if (a.toLowerCase() === "none") continue;
+    functions[fn] = parseSystems(a);
+  }
+}
+
+if (interactive && !given) {
   const modes = prefs ? ["recommended", "previous", "customize"] : ["recommended", "customize"];
-  const mode = await choose("Would you like to use the recommended Naive defaults?", modes, "recommended");
-  if (mode === "previous") answers = { ...recommended, ...prefs };
-  if (mode === "customize") {
-    answers.phase = await choose("Which phase is the venture in?", PHASES, "discovery");
-    const l = await ask(`Which layers should be on? (comma separated, from ${LAYERS.join(", ")}; empty for the phase's defaults: ${PHASE_LAYERS[answers.phase].join(", ")})`, "");
+  const pick = await choose("Would you like to use the recommended Naive defaults for the rest?", modes, "recommended");
+  if (pick === "previous") answers = { ...answers, layers: prefs.layers ?? null, legalForm: prefs.legalForm ?? null };
+  if (pick === "customize") {
+    const l = await ask(`Which layers should be on? (comma separated, from ${LAYERS.join(", ")}; empty for the defaults)`, "");
     answers.layers = l || null;
-    const f = await choose("Is the venture a legal entity yet?", ["none", "llc", "corporation", "partnership", "nonprofit"], "none");
+    const f = await choose("Is the venture a legal entity yet?", FORMS, "none");
     answers.legalForm = f === "none" ? null : f;
     const d = await ask("Paste the path of an idea dump to start from (optional)", "");
     answers.dump = d || null;
@@ -94,6 +198,7 @@ else if (interactive) {
 }
 if (!PHASES.includes(answers.phase)) fail(`unknown phase ${answers.phase}: one of ${PHASES.join(", ")}`);
 if (answers.dump && !existsSync(resolve(answers.dump))) fail(`no idea dump at ${answers.dump}`);
+if (answers.legalForm && !FORMS.includes(answers.legalForm)) fail(`unknown legal form ${answers.legalForm}: one of ${FORMS.join(", ")}`);
 
 // 3. The package manager: the flag, else whichever ran this (npm_config_user_agent), else npm.
 const pm = ["npm", "pnpm", "yarn", "bun"].find((p) => flag(`use-${p}`)) ?? (process.env.npm_config_user_agent ?? "").split("/")[0].replace(/^npx$/, "npm") ?? "npm";
@@ -101,20 +206,55 @@ const manager = ["npm", "pnpm", "yarn", "bun"].includes(pm) ? pm : "npm";
 rl?.close();
 
 // 4. The venture itself, by the framework's own scaffold.
-console.log(`\nCreating a new Naive venture in ${bold(dir)}.\n`);
-const init = spawnSync("node", [join(framework, "schema/init-venture.mjs"), dir, id, "--phase", answers.phase,
+console.log(`\nCreating a new ${vtype.label.toLowerCase()} in ${bold(dir)}, with ${mode === "solo" ? `${me} as its ${role}, wearing every hat` : `${people.length} founders`}.\n`);
+const init = spawnSync("node", [join(framework, "schema/init-venture.mjs"), dir, id, "--phase", answers.phase, "--type", vtype.id,
   ...(answers.layers ? ["--layers", answers.layers] : []), ...(answers.legalForm ? ["--legal-form", answers.legalForm] : [])], { encoding: "utf8" });
 if (init.status !== 0) fail((init.stderr || init.stdout).trim());
 const vfile = join(dir, "venture.json");
 const venture = JSON.parse(readFileSync(vfile, "utf8"));
 venture.name = basename(dir);
+if (mode === "team") venture.members = people.slice(1).map((p) => ({ role: p.role === "general-partner" ? "partner" : p.role, kind: "person" }));
 writeFileSync(vfile, JSON.stringify(venture, null, 2) + "\n");
 
+// people/: the roster and one file per founder, the venture.json of human capital (EE-082).
 const { agentFromEnv, record } = await import(join(framework, "interface/provenance.mjs"));
+const today = new Date().toISOString().slice(0, 10);
+mkdirSync(join(dir, "people/founders"), { recursive: true });
+const asPerson = agentFromEnv("person", "cli", { id: people[0].id });
+for (const p of people.filter((x) => roleOf(x.role)?.founder)) {
+  p.founder_file = `people/founders/${p.id}.json`;
+  writeFileSync(join(dir, p.founder_file), JSON.stringify({ id: p.id, name: p.name, role: p.role, hats: p.hats, joined: today }, null, 2) + "\n");
+  record(dir, { entity: p.founder_file, route: `people/founders/${p.id}`, activity: "write", agent: asPerson, note: `${p.name}, ${p.role}, as answered at create-venture` });
+}
+writeFileSync(join(dir, "people/people.json"), JSON.stringify({ venture: id, mode, people: people.map(({ id: pid, name, role: r, hats, founder_file }) => ({ id: pid, name, role: r, hats, ...(founder_file ? { founder_file } : {}) })), updated: today }, null, 2) + "\n");
+record(dir, { entity: "people/people.json", route: "people", activity: "write", agent: asPerson, note: `${mode}: ${people.map((p) => `${p.name} (${p.role})`).join(", ")}` });
 if (answers.dump) {
   mkdirSync(join(dir, "raw"), { recursive: true });
   copyFileSync(resolve(answers.dump), join(dir, "raw/dump.md"));
-  record(dir, { entity: "raw/dump.md", route: "raw/dump", activity: "create", agent: agentFromEnv("person", "create-venture"), note: `the founder's idea dump, verbatim, from ${resolve(answers.dump)}` });
+  record(dir, { entity: "raw/dump.md", route: "raw/dump", activity: "write", agent: agentFromEnv("person", "cli"), note: `the founder's idea dump, verbatim, from ${resolve(answers.dump)}` });
+}
+
+// knowledge/sources.json: each function's systems of record, as pointers (EE-083). Rho is read by code, so it is synced now.
+const rhoScript = join(framework, "platform/integrations/rho.mjs");
+let rhoNote = null;
+for (const f of Object.values(functions)) for (const s of f.systems) {
+  s.status = "pointed";
+  if (s.system !== "rho") continue;
+  if (!existsSync(rhoScript)) { rhoNote = "Rho: recorded as pointed; this copy of Naive has no Rho integration"; continue; }
+  const fixture = flag("rho-fixture") ? join(framework, "platform/integrations/fixtures/rho-sandbox.json") : null;
+  const live = !fixture && process.env.RHO_API_TOKEN;
+  const r = spawnSync("node", [rhoScript, "sync", "--venture", dir, ...(fixture ? ["--fixture", fixture] : live ? ["--live"] : [])], { encoding: "utf8", env: process.env });
+  if (r.status === 0) {
+    Object.assign(s, { status: "connected", synced: new Date().toISOString().replace(/\.\d+Z$/, "Z"), ...(fixture ? { fixture: true } : {}), address: s.address ?? (fixture ? "saved sandbox answer" : live ? "live" : "sandbox") });
+    rhoNote = `Rho: synced ${fixture ? "from a saved sandbox answer (a fixture, not a live account)" : live ? "from your Rho account" : "from Rho's sandbox (a fictional company)"} into money/`;
+  } else rhoNote = `Rho: could not sync (${(r.stderr || r.stdout).trim().split("\n").at(-1)}); recorded as pointed`;
+}
+if (Object.keys(functions).length) {
+  const map = join(dir, "knowledge/sources.json");
+  mkdirSync(dirname(map), { recursive: true });
+  writeFileSync(map, JSON.stringify({ sources: [], records: {}, truth: "local", functions }, null, 2) + "\n");
+  record(dir, { entity: "knowledge/sources.json", route: "knowledge/knowledge-sources", activity: "write", agent: asPerson,
+    note: `systems of record: ${Object.entries(functions).map(([fn, f]) => `${fn} ${f.systems.map((s) => `${s.system} (${s.status})`).join(", ") || "in the founder's words"}`).join("; ")}` });
 }
 
 // The venture's package.json: the framework as a dev dependency and the four scripts (I-17).
@@ -126,7 +266,7 @@ writeFileSync(join(dir, "package.json"), JSON.stringify({
   scripts: { dev: "naive dev", build: "naive build", start: "naive start", check: "naive check" },
   devDependencies: { [fw.name]: spec },
 }, null, 2) + "\n");
-writeFileSync(join(dir, ".gitignore"), "node_modules/\n.naive/\n.DS_Store\n# Founder-supplied originals stay out of git (EE-070).\n**/raw/**/original.*\n");
+writeFileSync(join(dir, ".gitignore"), "node_modules/\n.naive/\n.DS_Store\n# Founder-supplied originals stay out of git (EE-070).\n**/raw/**/original.*\n# A data stream's activity (bank transactions, CRM events) stays out of git; only its stream.json and summary.md are versioned.\n/*/_streams/*/*\n!/*/_streams/*/stream.json\n!/*/_streams/*/summary.md\n");
 
 // Editor completion for records (I-26): every record file is mapped to its JSON Schema in the installed framework.
 const { routes } = await import(join(framework, "interface/router.mjs"));
@@ -151,13 +291,14 @@ if (!flag("no-git") && spawnSync("git", ["--version"]).status === 0 && spawnSync
   git = c.status === 0 ? "initialized, with a first commit" : "initialized; the first commit was skipped because git has no user.name and user.email";
 } else if (!flag("no-git")) git = "skipped (already inside a git repository)";
 
-try { mkdirSync(dirname(prefsFile), { recursive: true }); writeFileSync(prefsFile, JSON.stringify({ phase: answers.phase, layers: answers.layers, legalForm: answers.legalForm }, null, 2) + "\n"); } catch {}
+try { mkdirSync(dirname(prefsFile), { recursive: true }); writeFileSync(prefsFile, JSON.stringify({ type: vtype.id, role, mode, phase: answers.phase, layers: answers.layers, legalForm: answers.legalForm }, null, 2) + "\n"); } catch {}
 
 const runScript = (s) => (manager === "npm" ? `npm run ${s}` : `${manager} ${s}`);
 const cd = relative(process.cwd(), dir) || ".";
+const legal = functions.legal?.systems.length ? null : "Legal documents: none connected yet. Point Naive at them later with --source legal=google-drive:<folder> (or docusign, local-folder), and draft the founder agreement with the founding-agreement kit.";
 console.log(`
 ${bold("Success!")} Created ${basename(dir)} at ${dir}
-Git: ${git}
+Git: ${git}${rhoNote ? `\n${rhoNote}` : ""}${legal ? `\n${legal}` : ""}
 
 Inside that directory, you can run:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-venture",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Create a new Naive venture: npx create-venture my-venture",
   "type": "module",
   "license": "MIT",
@@ -20,6 +20,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "naive-framework": "^0.1.0"
+    "naive-framework": "^0.2.0"
   }
 }