@lovelaces-io/storyteller 0.2.0 → 0.3.0

package/dist/cli.cjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  detectPackageManager: () => detectPackageManager,
+  initializeProject: () => initializeProject,
+  readSnippet: () => readSnippet
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var SECTION_START = "<!-- storyteller:begin -->";
+var SECTION_END = "<!-- storyteller:end -->";
+var PACKAGE_NAME = "@lovelaces-io/storyteller";
+var GUIDANCE_FILES = ["AGENTS.md", "CLAUDE.md"];
+var PACKAGE_MANAGERS = [
+  { name: "pnpm", lockfile: "pnpm-lock.yaml", install: ["add"] },
+  { name: "yarn", lockfile: "yarn.lock", install: ["add"] },
+  { name: "bun", lockfile: "bun.lockb", install: ["add"] },
+  { name: "npm", lockfile: "package-lock.json", install: ["install"] }
+];
+function initializeProject(projectRoot, options = {}) {
+  const result = { changed: [], skipped: [], notes: [] };
+  const packageJsonPath = (0, import_node_path.join)(projectRoot, "package.json");
+  if (!(0, import_node_fs.existsSync)(packageJsonPath)) {
+    throw new Error(
+      "No package.json here. Run this from the root of a Node project."
+    );
+  }
+  if (options.install !== false) {
+    installDependency(projectRoot, packageJsonPath, result);
+  }
+  writeStarterModule(projectRoot, packageJsonPath, result);
+  writeGuidanceSection(projectRoot, result);
+  return result;
+}
+function installDependency(projectRoot, packageJsonPath, result) {
+  const manifest = readJson(packageJsonPath);
+  const dependencies = {
+    ...manifest["dependencies"],
+    ...manifest["devDependencies"]
+  };
+  if (dependencies[PACKAGE_NAME]) {
+    result.skipped.push(`${PACKAGE_NAME} (already a dependency)`);
+    return;
+  }
+  const manager = detectPackageManager(projectRoot);
+  try {
+    (0, import_node_child_process.execFileSync)(manager.name, [...manager.install, PACKAGE_NAME], {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+    result.changed.push(`installed ${PACKAGE_NAME} with ${manager.name}`);
+  } catch {
+    result.notes.push(
+      `Could not install automatically. Run: ${manager.name} ${manager.install.join(" ")} ${PACKAGE_NAME}`
+    );
+  }
+}
+function detectPackageManager(projectRoot) {
+  for (const manager of PACKAGE_MANAGERS) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(projectRoot, manager.lockfile))) return manager;
+  }
+  return PACKAGE_MANAGERS[PACKAGE_MANAGERS.length - 1];
+}
+function writeStarterModule(projectRoot, packageJsonPath, result) {
+  const sourceDirectory = (0, import_node_fs.existsSync)((0, import_node_path.join)(projectRoot, "src")) ? "src" : ".";
+  const starterPath = (0, import_node_path.join)(projectRoot, sourceDirectory, "storyteller.ts");
+  if ((0, import_node_fs.existsSync)(starterPath)) {
+    result.skipped.push(`${sourceDirectory}/storyteller.ts (already exists)`);
+    return;
+  }
+  const manifest = readJson(packageJsonPath);
+  const projectName = typeof manifest["name"] === "string" && manifest["name"].length ? manifest["name"].replace(/^@[^/]+\//, "") : "app";
+  (0, import_node_fs.writeFileSync)(
+    starterPath,
+    `import { Storyteller } from "${PACKAGE_NAME}";
+
+/**
+ * The storyteller for this project. Import it wherever work happens.
+ *
+ * Set STORYTELLER_NARRATION=live to watch beats stream as they happen.
+ */
+export const story = new Storyteller({
+  origin: { who: ${JSON.stringify(projectName)} },
+});
+`,
+    "utf8"
+  );
+  result.changed.push(`${sourceDirectory}/storyteller.ts`);
+}
+function writeGuidanceSection(projectRoot, result) {
+  const snippet = readSnippet();
+  const block = `${SECTION_START}
+${snippet.trim()}
+${SECTION_END}
+`;
+  const existing = GUIDANCE_FILES.map((name) => (0, import_node_path.join)(projectRoot, name)).find(
+    (path) => (0, import_node_fs.existsSync)(path)
+  );
+  const targetPath = existing ?? (0, import_node_path.join)(projectRoot, GUIDANCE_FILES[0]);
+  const relativeName = targetPath.slice(projectRoot.length + 1);
+  if (!existing) {
+    (0, import_node_fs.writeFileSync)(targetPath, `# Agent Guide
+
+${block}`, "utf8");
+    result.changed.push(`${relativeName} (created)`);
+    return;
+  }
+  const current = (0, import_node_fs.readFileSync)(targetPath, "utf8");
+  const startIndex = current.indexOf(SECTION_START);
+  if (startIndex === -1) {
+    (0, import_node_fs.writeFileSync)(targetPath, `${current.trimEnd()}
+
+${block}`, "utf8");
+    result.changed.push(relativeName);
+    return;
+  }
+  const endIndex = current.indexOf(SECTION_END, startIndex);
+  if (endIndex === -1) {
+    result.notes.push(
+      `${relativeName} has an unterminated ${SECTION_START} block. Fix or remove it, then re-run.`
+    );
+    return;
+  }
+  const before = current.slice(0, startIndex);
+  const after = current.slice(endIndex + SECTION_END.length);
+  const updated = `${before}${block.trimEnd()}${after}`;
+  if (updated === current) {
+    result.skipped.push(`${relativeName} (already up to date)`);
+    return;
+  }
+  (0, import_node_fs.writeFileSync)(targetPath, updated, "utf8");
+  result.changed.push(`${relativeName} (guidance refreshed)`);
+}
+function readSnippet() {
+  const candidates = [
+    (0, import_node_path.join)(__dirname, "..", "snippets", "agents-section.md"),
+    (0, import_node_path.join)(__dirname, "..", "..", "snippets", "agents-section.md")
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) return (0, import_node_fs.readFileSync)(candidate, "utf8");
+  }
+  throw new Error("Could not find the guidance snippet that ships with this package.");
+}
+function readJson(path) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch (error) {
+    throw new Error(`Could not read ${path}: ${error.message}`, {
+      cause: error
+    });
+  }
+}
+function main(argv) {
+  const command = argv[0] ?? "init";
+  if (command === "--help" || command === "-h" || command === "help") {
+    console.log(
+      [
+        "npx @lovelaces-io/storyteller init [--no-install]",
+        "  (or `storyteller init` once the package is installed)",
+        "",
+        "  Sets this project up to use Storyteller:",
+        "    - installs the package",
+        "    - writes a configured storyteller",
+        "    - teaches your agents to narrate their work",
+        "",
+        "  Safe to run more than once."
+      ].join("\n")
+    );
+    return;
+  }
+  if (command !== "init") {
+    console.error(`Unknown command: ${command}
+Try: storyteller init`);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const result = initializeProject(process.cwd(), {
+      install: !argv.includes("--no-install")
+    });
+    for (const change of result.changed) console.log(`  added    ${change}`);
+    for (const skip of result.skipped) console.log(`  kept     ${skip}`);
+    for (const note of result.notes) console.log(`  note     ${note}`);
+    console.log("\nTry it:");
+    console.log("  STORYTELLER_NARRATION=live node your-script.js");
+  } catch (error) {
+    console.error(`storyteller init failed: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+if (require.main === module) {
+  main(process.argv.slice(2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectPackageManager,
+  initializeProject,
+  readSnippet
+});