@thebassclef/lite 0.1.2 → 1.0.0

package/dist/cli.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import { version } from "./index.js";
-import { realpathSync, statSync, constants, lstatSync, mkdirSync, accessSync, unlinkSync, openSync, writeSync, closeSync, readFileSync, existsSync } from "node:fs";
-import { isAbsolute, resolve, dirname, join } from "node:path";
+import { realpathSync, statSync, constants, lstatSync, mkdirSync, accessSync, unlinkSync, openSync, writeSync, closeSync, readFileSync, readdirSync, existsSync } from "node:fs";
+import { isAbsolute, resolve, dirname, join, relative, basename as basename$1 } from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
 import { stdin, stderr, stdout } from "node:process";
 const DEFAULTS$2 = {
@@ -220,22 +219,6 @@ function hashContent(content) {
   normalized = normalized.replace(/\r\n/g, "\n");
   return createHash("sha256").update(normalized, "utf8").digest("hex");
 }
-const SETTINGS_TEMPLATE_VERSION = "0.0.1";
-function settingsJsonTemplate(pkgVersion) {
-  const value = {
-    $bassclef: {
-      template: "settings.json",
-      template_version: SETTINGS_TEMPLATE_VERSION,
-      generated_by: "@thebassclef/core",
-      generated_by_version: pkgVersion
-    },
-    permissions: {
-      additionalDirectories: []
-    },
-    hooks: {}
-  };
-  return JSON.stringify(value, null, 2) + "\n";
-}
 const SUBSTRATE_CONFIG_TEMPLATE_VERSION = "0.0.1";
 function substrateConfigMdTemplate(pkgVersion) {
   return [
@@ -386,129 +369,215 @@ async function computeConfigHashes(targetDir, paths) {
   }
   return out;
 }
-const SUBSTRATE_ROOT = "substrate";
-const CONFIG_FILES = [
-  ".claude/settings.json",
-  "substrate.config.md",
-  "substrate.secrets.md"
-];
-const CURRENT_ENTRY_COUNT = 149;
+const EXPECTED_WIRING_SCHEMA_MAJOR = 2;
+const WIRING_MANIFEST_RELATIVE = "standards/bassclef-wiring-manifest.json";
+class CopyFailure extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "CopyFailure";
+  }
+}
 function copySubstrate(targetDir, options = {}) {
   const bundleRoot = resolveBundleRoot(options.bundleRoot);
-  const manifest = loadBundledManifest(bundleRoot);
+  const manifest = readWiringManifest(bundleRoot);
   const result = {
     copied: [],
     refused: [],
     errored: [],
-    erroredMessages: []
+    erroredMessages: [],
+    hookCount: 0,
+    wiringVersion: manifest.version
   };
   if (options.dryRun) result.wouldCopy = [];
-  const groups = groupByTopDirectory(manifest.entries);
-  for (const [directory, entries] of groups) {
+  const files = walkDistTree(bundleRoot);
+  const groups = groupByTopDirectory(files);
+  for (const [directory, groupFiles] of groups) {
     let completedInGroup = 0;
-    for (const entry of entries) {
-      const outcome = copyOne(entry, bundleRoot, targetDir, options, result);
+    for (const relPath of groupFiles) {
+      const outcome = copyOne(relPath, bundleRoot, targetDir, options, result);
       if (outcome !== "skipped") completedInGroup += 1;
     }
     if (options.onProgress) options.onProgress(directory, completedInGroup);
   }
+  result.hookCount = readHookCount(
+    options.dryRun ? join(bundleRoot, ".claude/settings.json") : join(targetDir, ".claude/settings.json")
+  );
   return result;
 }
-function copyOne(entry, bundleRoot, targetDir, options, result) {
-  const sourcePath = join(bundleRoot, entry.path);
-  const targetPath = join(targetDir, entry.path);
+function readWiringManifest(bundleRoot) {
+  const manifestPath = join(bundleRoot, WIRING_MANIFEST_RELATIVE);
+  if (!fileExists(manifestPath)) {
+    throw new CopyFailure(
+      "ManifestMissing",
+      `Wiring manifest missing at ${manifestPath}. Cli built for schema_version ${EXPECTED_WIRING_SCHEMA_MAJOR}.x. Run \`npm install @thebassclef/lite@latest\` to fix.`
+    );
+  }
+  let manifest;
+  let raw;
+  try {
+    raw = readFileSync(manifestPath, "utf8");
+  } catch (e) {
+    const err = e;
+    throw new CopyFailure(
+      "ManifestMissing",
+      `Wiring manifest at ${manifestPath} unreadable (${err.code ?? "unknown"}). Reinstall @thebassclef/lite to restore the bundle.`
+    );
+  }
+  try {
+    manifest = JSON.parse(raw);
+  } catch (e) {
+    const err = e;
+    throw new CopyFailure(
+      "SchemaIncompatible",
+      `Wiring manifest at ${manifestPath} is not valid JSON: ${err.message}. Reinstall @thebassclef/lite to restore the bundle.`
+    );
+  }
+  if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+    throw new CopyFailure(
+      "SchemaIncompatible",
+      `Wiring manifest at ${manifestPath} missing 'version' field. Cli requires schema_version ${EXPECTED_WIRING_SCHEMA_MAJOR}.x. Reinstall @thebassclef/lite to fix.`
+    );
+  }
+  const major = parseInt(manifest.version.split(".")[0] ?? "0", 10);
+  if (major !== EXPECTED_WIRING_SCHEMA_MAJOR) {
+    throw new CopyFailure(
+      "SchemaIncompatible",
+      `Wiring manifest at ${manifestPath} has version ${manifest.version}. Cli built for schema_version ${EXPECTED_WIRING_SCHEMA_MAJOR}.x. Upgrade cli OR downgrade @thebassclef/lite to a compatible version.`
+    );
+  }
+  return { version: manifest.version };
+}
+function walkDistTree(bundleRoot) {
+  if (!dirExists(bundleRoot)) {
+    throw new CopyFailure(
+      "BundleMissing",
+      `Bundled substrate missing at ${bundleRoot}. Reinstall @thebassclef/lite to restore the bundle.`
+    );
+  }
+  const results = [];
+  function walk(dir) {
+    for (const name of readdirSync(dir)) {
+      const full = join(dir, name);
+      const st = statSync(full);
+      if (st.isDirectory()) walk(full);
+      else results.push(relative(bundleRoot, full));
+    }
+  }
+  walk(bundleRoot);
+  results.sort();
+  return results;
+}
+const GITIGNORE_BUNDLE_NAME = "gitignore";
+const GITIGNORE_ADOPTER_NAME = ".gitignore";
+function mapAdopterPath(relPath) {
+  if (relPath === GITIGNORE_BUNDLE_NAME) return GITIGNORE_ADOPTER_NAME;
+  return relPath;
+}
+function copyOne(relPath, bundleRoot, targetDir, options, result) {
+  const sourcePath = join(bundleRoot, relPath);
+  const adopterRelPath = mapAdopterPath(relPath);
+  const targetPath = join(targetDir, adopterRelPath);
   let content;
   try {
     content = readFileSync(sourcePath, "utf8");
   } catch (e) {
     const err = e;
-    const message = `${entry.path} — cannot read bundled source (${err.code ?? "unknown"}). Reinstall @thebassclef/core to restore the bundle.`;
-    result.errored.push(entry.path);
-    result.erroredMessages?.push(message);
-    return "errored";
-  }
-  const declaredHash = stripHashPrefix(entry.content_hash);
-  const actualHash = sha256Hex(content);
-  if (declaredHash !== actualHash) {
-    const message = `${entry.path} — bundled content hash does not match the manifest. Reinstall @thebassclef/core to repair the bundle, then rerun bassclef init --force.`;
-    result.errored.push(entry.path);
+    const message = `${relPath} — cannot read bundled source (${err.code ?? "unknown"}). Reinstall @thebassclef/lite to restore the bundle.`;
+    result.errored.push(adopterRelPath);
     result.erroredMessages?.push(message);
     return "errored";
   }
+  const outputContent = options.transform ? options.transform(adopterRelPath, content) : content;
   if (options.dryRun) {
-    result.wouldCopy?.push(entry.path);
+    result.wouldCopy?.push(adopterRelPath);
     return "wouldCopy";
   }
   try {
     mkdirSafely(dirname(targetPath));
-    writeSafely(targetPath, content, { force: options.force ?? false });
-    result.copied.push(entry.path);
+    writeSafely(targetPath, outputContent, { force: options.force ?? false });
+    result.copied.push(adopterRelPath);
     return "copied";
   } catch (e) {
     if (e instanceof WriteError) {
       if (e.kind === "AlreadyExists") {
-        result.refused.push(entry.path);
+        result.refused.push(adopterRelPath);
         return "refused";
       }
       if (e.kind === "SymlinkRefused") {
-        result.refused.push(entry.path);
+        result.refused.push(adopterRelPath);
         return "refused";
       }
-      const message = `${entry.path} — write failed (${e.kind}): ${e.message}. Check the target directory exists and is writable, then rerun.`;
-      result.errored.push(entry.path);
+      const message = `${adopterRelPath} — write failed (${e.kind}): ${e.message}. Check the target directory exists and is writable, then rerun.`;
+      result.errored.push(adopterRelPath);
       result.erroredMessages?.push(message);
       return "errored";
     }
     throw e;
   }
 }
-function loadBundledManifest(bundleRoot) {
-  const manifestPath = join(bundleRoot, ".bassclef", "lite-manifest.json");
-  const raw = readFileSync(manifestPath, "utf8");
-  const parsed = JSON.parse(raw);
-  if (!Array.isArray(parsed.entries)) {
-    throw new Error(
-      `bundled manifest at ${manifestPath} has no entries[] array. Reinstall @thebassclef/core to restore the bundle.`
-    );
-  }
-  return parsed;
-}
 function resolveBundleRoot(explicit) {
   if (explicit && explicit.length > 0) return resolve(explicit);
   const thisFile = fileURLToPath(import.meta.url);
   let dir = dirname(thisFile);
   for (let i = 0; i < 5; i += 1) {
-    try {
-      readFileSync(join(dir, "package.json"), "utf8");
-      return join(dir, SUBSTRATE_ROOT);
-    } catch {
-      const parent = dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
+    if (fileExists(join(dir, "package.json"))) {
+      return join(dir, "dist", "lite");
     }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
-  const require2 = createRequire(import.meta.url);
-  const pkgJsonPath = require2.resolve("@thebassclef/core/package.json");
-  const pkgRoot = dirname(pkgJsonPath);
-  return join(pkgRoot, SUBSTRATE_ROOT);
+  throw new CopyFailure(
+    "BundleMissing",
+    `Cannot resolve bundled substrate root — package.json unreachable from ${thisFile}. Reinstall @thebassclef/lite.`
+  );
 }
-function groupByTopDirectory(entries) {
+function groupByTopDirectory(files) {
   const groups = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const parts = entry.path.split("/");
+  for (const p of files) {
+    const parts = p.split("/");
     const top = parts.length >= 2 ? parts.slice(0, 2).join("/") : parts[0] ?? "";
     if (!groups.has(top)) groups.set(top, []);
-    groups.get(top).push(entry);
+    groups.get(top).push(p);
   }
   return groups;
 }
-function stripHashPrefix(value) {
-  const prefix = "sha256:";
-  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+function readHookCount(settingsPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+    let count = 0;
+    for (const matcherBlocks of Object.values(parsed.hooks ?? {})) {
+      for (const block of matcherBlocks) {
+        count += (block.hooks ?? []).length;
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function fileExists(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
 }
-function sha256Hex(content) {
-  return createHash("sha256").update(content).digest("hex");
+function dirExists(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
 }
+const RESOLVED_TIER = "lite";
+const PLACEHOLDER_FILES = /* @__PURE__ */ new Set([
+  "CLAUDE.md",
+  "docs/whereami.md",
+  "whereami.md",
+  ".bassclef-source.json"
+]);
 function runInit(argv) {
   let args;
   try {
@@ -554,14 +623,6 @@ function runInit(argv) {
     }
   }
   const plans = [
-    {
-      label: "settings.json",
-      relativePath: ".claude/settings.json",
-      fullPath: join(targetDir, ".claude", "settings.json"),
-      content: settingsJsonTemplate(version),
-      templateName: "settings.json",
-      templateVersion: SETTINGS_TEMPLATE_VERSION
-    },
     {
       label: "substrate.config.md",
       relativePath: "substrate.config.md",
@@ -572,32 +633,51 @@ function runInit(argv) {
     }
   ];
   if (args.dryRun) {
-    return runDryRun$1(plans);
-  }
-  const exitCode = runReal$1(plans, args.force, args.verbose, targetDir);
-  if (exitCode === 0) {
-    dispatchSubstrateCopy(targetDir, args.force, args.verbose);
+    runDryRun$1(plans);
+    return dispatchSubstrateCopy(targetDir, args.force, args.verbose, true);
   }
-  return exitCode;
+  return runReal$1(plans, args.force, args.verbose, targetDir);
 }
-function dispatchSubstrateCopy(targetDir, force, verbose) {
+function dispatchSubstrateCopy(targetDir, force, verbose, dryRun) {
+  const substitute = makePlaceholderTransform(targetDir);
   let result;
   try {
-    result = copySubstrate(targetDir, { force });
+    result = copySubstrate(targetDir, {
+      force,
+      dryRun,
+      transform: substitute
+    });
   } catch (e) {
-    const err = e;
-    process.stderr.write(
-      `bassclef init: substrate copy failed — ${err.message}
-  cause: the installed @thebassclef/core package is missing the bundled substrate manifest.
-  fix: reinstall with \`npm install -g @thebassclef/core@latest --force\`.
-       If the reinstall does not help, file an issue at
-       https://github.com/sunj-labs/bassclef-cli/issues with your package version.
+    if (e instanceof CopyFailure) {
+      process.stderr.write(`bassclef init: ${e.message}
+`);
+      if (e.kind === "ManifestMissing") return 4;
+      if (e.kind === "SchemaIncompatible") return 5;
+      return 2;
+    }
+    throw e;
+  }
+  if (dryRun) {
+    const wouldCopy = result.wouldCopy ?? [];
+    for (const relativePath of wouldCopy) {
+      const targetPath = join(targetDir, relativePath);
+      process.stdout.write(`  ${"would create".padEnd(14)} ${targetPath}
+`);
+    }
+    if (wouldCopy.length > 0) {
+      process.stdout.write(
+        `bassclef init: ${wouldCopy.length} substrate files would be copied.
+`
+      );
+    }
+    process.stdout.write(
+      `bassclef init: ${result.hookCount} hooks armed (${RESOLVED_TIER} tier).
 `
     );
-    process.exit(2);
+    return 0;
   }
   if (result.copied.length === 0 && result.refused.length === 0 && result.errored.length === 0) {
-    return;
+    return 0;
   }
   const groupCounts = /* @__PURE__ */ new Map();
   for (const path of result.copied) {
@@ -615,12 +695,30 @@ function dispatchSubstrateCopy(targetDir, force, verbose) {
   if (result.errored.length > 0) parts.push(`${result.errored.length} error(s)`);
   process.stdout.write(`bassclef init: ${parts.join(", ")}.
 `);
+  const grandTotal = 1 + result.copied.length;
+  process.stdout.write(
+    `bassclef init: ${grandTotal} files total (1 config + ${result.copied.length} substrate).
+`
+  );
+  process.stdout.write(
+    `bassclef init: ${result.hookCount} hooks armed (${RESOLVED_TIER} tier).
+`
+  );
   if (verbose && result.erroredMessages) {
     for (const msg of result.erroredMessages) {
       process.stderr.write(`  substrate: ${msg}
 `);
     }
   }
+  return result.errored.length > 0 ? 2 : 0;
+}
+function makePlaceholderTransform(targetDir) {
+  const repoName = basename$1(targetDir);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return (relPath, content) => {
+    if (!PLACEHOLDER_FILES.has(relPath)) return content;
+    return content.replace(/\[REPO_NAME\]/g, repoName).replace(/\[ISO_TIMESTAMP\]/g, timestamp).replace(/\[TIER\]/g, RESOLVED_TIER).replace(/\[Repo name\]/g, repoName).replace(/<tier>/g, RESOLVED_TIER);
+  };
 }
 function runDryRun$1(plans) {
   for (const p of plans) {
@@ -704,8 +802,8 @@ function runReal$1(plans, force, verbose, targetDir) {
     process.stderr.write(`bassclef init: ${tag}: ${r.message ?? "write failed"}: ${r.plan.fullPath}
 `);
   }
-  writeManifest(targetDir, results);
   if (anyError) {
+    writeManifest(targetDir, results);
     const parts = [];
     if (created > 0) parts.push(`${created} created`);
     if (unchanged > 0) parts.push(`${unchanged} unchanged`);
@@ -716,28 +814,26 @@ function runReal$1(plans, force, verbose, targetDir) {
 `);
     return 2;
   }
-  if (created === 0 && unchanged === plans.length) {
-    process.stdout.write("bassclef init: already initialized. No changes.\n");
-    return 0;
-  }
   if (anyRefused && created > 0) {
     process.stdout.write(
-      `bassclef init: ${created} created, ${unchanged} unchanged. Pass --force to overwrite.
+      `bassclef init: ${created} config files created, ${unchanged} unchanged. Pass --force to overwrite.
 `
     );
+  } else if (created === 0 && unchanged === plans.length) {
+    process.stdout.write("bassclef init: already initialized. No changes.\n");
+  } else {
+    process.stdout.write(`bassclef init: ${created} config files created, ${unchanged} unchanged.
+`);
+  }
+  const walkerExit = dispatchSubstrateCopy(targetDir, force, verbose, false);
+  writeManifest(targetDir, results);
+  if (walkerExit === 0) {
     process.stdout.write(
       `bassclef init: your substrate lives under .claude/. Add .claude/ to .gitignore if you have not.
 `
     );
-    return 0;
   }
-  process.stdout.write(`bassclef init: ${created} created, ${unchanged} unchanged.
-`);
-  process.stdout.write(
-    `bassclef init: your substrate lives under .claude/. Add .claude/ to .gitignore if you have not.
-`
-  );
-  return 0;
+  return walkerExit;
 }
 function shouldRefuseRoot(currentUid, allowRoot) {
   if (currentUid === void 0) return false;
@@ -785,10 +881,25 @@ function usage$2() {
     "  --allow-any-dir    Allow --dir outside your home directory. Default: refuse.",
     "  --verbose          Print per-file result.",
     "",
+    "Exit codes:",
+    "  0 — success",
+    "  1 — refused by policy (existing file; running as root; outside HOME)",
+    "  2 — safety check failed at write (symlink; parent not writable)",
+    "  3 — invalid args",
+    "  4 — wiring manifest missing from bundled substrate (reinstall @thebassclef/lite)",
+    "  5 — wiring manifest schema major version incompatible with this cli",
+    "",
     "Files written under <target>:",
-    "  .claude/settings.json          Claude Code settings (minimal, opt-in blocks)",
     "  substrate.config.md            Bassclef project manifest",
     "  .bassclef/init.manifest.json   Record of what init wrote (used by sync)",
+    "",
+    "  Plus the bundled substrate tree from dist/lite/:",
+    "  .claude/settings.json          Claude Code settings (verbatim from bundle)",
+    "  CLAUDE.md, whereami.md, .bassclef-source.json, .gitignore",
+    "                                 Templates with placeholders substituted",
+    "",
+    "  Run with --dry-run first to preview the full file list before",
+    "  writing anything to disk.",
     ""
   ].join("\n");
 }
@@ -867,12 +978,6 @@ function parseSyncArgs(argv) {
   return out;
 }
 const TEMPLATES = [
-  {
-    templateName: "settings.json",
-    currentVersion: SETTINGS_TEMPLATE_VERSION,
-    render: settingsJsonTemplate,
-    hasMarker: (c) => c.includes('"$bassclef"')
-  },
   {
     templateName: "substrate.config.md",
     currentVersion: SUBSTRATE_CONFIG_TEMPLATE_VERSION,
@@ -1324,6 +1429,12 @@ async function confirm(question, opts = {}) {
     rl.close();
   }
 }
+const CONFIG_FILES = [
+  ".claude/settings.json",
+  "substrate.config.md",
+  "substrate.secrets.md"
+];
+const CURRENT_ENTRY_COUNT = 149;
 async function detectAdopterState(targetDir) {
   let manifest;
   try {

package/dist/index.cjs

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const version = "0.1.2";
+const version = "1.0.0";
 exports.version = version;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export declare const version: "0.1.2";
+export declare const version: "1.0.0";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,4 @@
-const version = "0.1.2";
+const version = "1.0.0";
 export {
   version
 };

package/dist/lite/.bassclef-source.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://bassclef.sunj-labs/adopter/bassclef-source.schema.json",
+  "source_repo": "sunj-labs/bassclef",
+  "source_ref": "main",
+  "tier": "[TIER]",
+  "auto_sync": true,
+  "installed_at": "[ISO_TIMESTAMP]",
+  "installed_via": "bassclef-cli",
+  "notes": "Adopter-owned config. Change `auto_sync` to `false` to pause session-start substrate refresh. Change `tier` to opt into standard or ultra (requires re-run of `bassclef init --tier <T>`). Rename docs at https://github.com/sunj-labs/bassclef."
+}