@cofoundr/init 1.5.0

package/src/core/scaffold.mjs

@@ -0,0 +1,179 @@
+import { join, basename } from 'node:path';
+import { readdir, stat } from 'node:fs/promises';
+import { writeIfChanged, writeAlways } from './fs.mjs';
+import { readSourceFile } from './source.mjs';
+
+export async function writeScaffold({ repoPath, source, manifest, projectName, selectedTools, dryRun, force }) {
+  const today = new Date().toISOString().slice(0, 10);
+  const written = [];
+  const skipped = [];
+
+  const subs = {
+    PROJECT_NAME: projectName || basename(repoPath),
+    PROJECT_DESCRIPTION:
+      '<!-- Add a one-paragraph description. /cofoundr:plan or /cofoundr:onboard will fill this in. -->',
+    BUILD_INSTRUCTIONS:
+      '<!-- One block of copy-paste-ready commands. Examples: install, dev, test, build. -->',
+    CODE_CONVENTIONS:
+      '<!-- 3-6 bullet points. Stack pins, lint commands, format commands, test runner. -->',
+    TODAY: today,
+    COFOUNDR_VERSION: manifest.version,
+    TOOLS_JSON: JSON.stringify(selectedTools, null, 2),
+    TOOL_SHIMS: renderToolShims(selectedTools, manifest),
+  };
+
+  // 1) AGENTS.md at repo root.
+  const agentsTpl = await readSourceFile(source, 'scaffold/AGENTS.md.tmpl');
+  const agentsOut = applySubs(agentsTpl, subs);
+  const r = await writeIfChanged(join(repoPath, 'AGENTS.md'), agentsOut, { dryRun, force });
+  bump(r, written, skipped);
+
+  // 2) .cofoundr/ scaffold.
+  await copyTreeWithSubs({
+    sourceRoot: source.root,
+    sourceRel: 'scaffold/.cofoundr',
+    destRoot: join(repoPath, '.cofoundr'),
+    subs,
+    dryRun,
+    force,
+    written,
+    skipped,
+  });
+
+  // 3) Bundle the canonical commands and agents into .cofoundr/ so non-Claude tools have a single
+  //    well-known location to read from. Templates from cofoundr-system/templates/ are also copied
+  //    in as a project-local override surface (read-only by default).
+  await copyTree({
+    sourceRoot: source.root,
+    sourceRel: 'commands',
+    destRoot: join(repoPath, '.cofoundr', 'commands'),
+    dryRun,
+    force,
+    written,
+    skipped,
+  });
+  await copyTree({
+    sourceRoot: source.root,
+    sourceRel: 'agents',
+    destRoot: join(repoPath, '.cofoundr', 'agents'),
+    dryRun,
+    force,
+    written,
+    skipped,
+  });
+  await copyTree({
+    sourceRoot: source.root,
+    sourceRel: 'templates',
+    destRoot: join(repoPath, '.cofoundr', 'templates'),
+    dryRun,
+    force,
+    written,
+    skipped,
+  });
+
+  return { written, skipped };
+}
+
+function renderToolShims(selectedTools, manifest) {
+  const map = new Map(manifest.targets.map((t) => [t.id, t]));
+  return selectedTools
+    .map((id) => {
+      const t = map.get(id);
+      if (!t) return `- \`${id}\``;
+      const paths = t.config.map((p) => `\`${p}\``).join(', ');
+      return `- **${t.name}** — ${paths}`;
+    })
+    .join('\n');
+}
+
+function applySubs(text, subs) {
+  let out = text;
+  for (const [k, v] of Object.entries(subs)) {
+    out = out.replaceAll(`{{${k}}}`, v);
+  }
+  return out;
+}
+
+function bump(result, written, skipped) {
+  if (result.wrote) written.push(result.path);
+  else skipped.push({ path: result.path, reason: result.reason });
+}
+
+async function copyTreeWithSubs({ sourceRoot, sourceRel, destRoot, subs, dryRun, force, written, skipped }) {
+  const root = join(sourceRoot, sourceRel);
+  const items = await walk(root);
+  for (const rel of items) {
+    const srcAbs = join(root, rel);
+    const isTpl = rel.endsWith('.tmpl');
+    const destRel = isTpl ? rel.replace(/\.tmpl$/, '') : rel;
+    const destAbs = join(destRoot, destRel);
+    const raw = await readFileText(srcAbs);
+    const contents = isTpl ? applySubs(raw, subs) : raw;
+    const r = await writeIfChanged(destAbs, contents, { dryRun, force });
+    bump(r, written, skipped);
+  }
+}
+
+async function copyTree({ sourceRoot, sourceRel, destRoot, dryRun, force, written, skipped }) {
+  const root = join(sourceRoot, sourceRel);
+  const items = await walk(root);
+  for (const rel of items) {
+    const srcAbs = join(root, rel);
+    const destAbs = join(destRoot, rel);
+    const raw = await readFileText(srcAbs);
+    const r = await writeIfChanged(destAbs, raw, { dryRun, force });
+    bump(r, written, skipped);
+  }
+}
+
+async function walk(root) {
+  const out = [];
+  await walkInto(root, '', out);
+  return out;
+}
+
+async function walkInto(root, rel, out) {
+  let entries;
+  try {
+    entries = await readdir(join(root, rel), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const sub = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      await walkInto(root, sub, out);
+    } else if (e.isFile()) {
+      out.push(sub);
+    }
+  }
+}
+
+async function readFileText(p) {
+  const { readFile } = await import('node:fs/promises');
+  return readFile(p, 'utf8');
+}
+
+export async function writeProjectManifest({ repoPath, manifest, selectedTools, dryRun }) {
+  const today = new Date().toISOString().slice(0, 10);
+  const body = JSON.stringify(
+    {
+      $schema: 'https://cofoundr.ai/schemas/project-manifest.schema.json',
+      cofoundrVersion: manifest.version,
+      initializedAt: today,
+      tools: selectedTools,
+      layout: {
+        constitution: '.cofoundr/constitution.md',
+        memory: '.cofoundr/memory/',
+        specs: '.cofoundr/specs/',
+        commands: '.cofoundr/commands/',
+        agents: '.cofoundr/agents/',
+        docs: '.cofoundr/docs/',
+        reports: '.cofoundr/reports/',
+      },
+    },
+    null,
+    2
+  ) + '\n';
+  return writeAlways(join(repoPath, '.cofoundr', 'manifest.json'), body, { dryRun });
+}

package/src/core/source.mjs

@@ -0,0 +1,54 @@
+// Locates the canonical CoFoundr content (commands, agents, templates, scaffold)
+// in two modes:
+//   1) Bundled — when the package was published to npm, content is at packages/cofoundr-cli/content/
+//   2) Dev     — when running from a checkout, content lives at <repo>/cofoundr-system/
+
+import { readFile, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = resolve(here, '..', '..');
+
+export async function locateSource() {
+  const bundled = join(pkgRoot, 'content');
+  if (existsSync(join(bundled, 'manifest.json'))) {
+    return { root: bundled, mode: 'bundled' };
+  }
+
+  // Dev: walk up looking for cofoundr-system/manifest.json
+  let dir = pkgRoot;
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, 'cofoundr-system');
+    if (existsSync(join(candidate, 'manifest.json'))) {
+      return { root: candidate, mode: 'dev' };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  throw new Error(
+    'Could not locate the CoFoundr canonical content. Expected either ' +
+      `${join(pkgRoot, 'content')} (bundled) or a sibling cofoundr-system/ directory.`
+  );
+}
+
+export async function loadManifest(source) {
+  const raw = await readFile(join(source.root, 'manifest.json'), 'utf8');
+  return JSON.parse(raw);
+}
+
+export async function readSourceFile(source, relPath) {
+  return readFile(join(source.root, relPath), 'utf8');
+}
+
+export async function sourceFileExists(source, relPath) {
+  try {
+    await stat(join(source.root, relPath));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/core/version.mjs

@@ -0,0 +1,10 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+export async function version() {
+  const pkg = JSON.parse(await readFile(join(here, '..', '..', 'package.json'), 'utf8'));
+  return pkg.version;
+}