@open-press/cli 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 quan0715
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OF OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# @open-press/cli
+
+Scaffolder for [open-press](https://github.com/quan0715/open-press) — an AI-first fixed-layout document workspace.
+
+## Quick start
+
+```bash
+npx @open-press/cli init my-doc --pack editorial-monograph
+cd my-doc
+npm run dev
+```
+
+Then open the local URL printed by Vite (typically `http://127.0.0.1:5173/?dev=1`).
+
+## Usage
+
+```
+npx @open-press/cli init <target> [flags]
+```
+
+| Flag                 | Description                                                                 |
+| -------------------- | --------------------------------------------------------------------------- |
+| `--pack <name>`      | Style pack starter: `editorial-monograph` or `claude-document`              |
+| `--title <s>`        | Document title (written to `openpress.config.mjs`)                          |
+| `--subtitle <s>`     | Document subtitle                                                           |
+| `--organization <s>` | Organization name                                                           |
+| `--author <s>`       | Author name                                                                 |
+| `--no-git`           | Skip `git init`                                                             |
+| `--no-install`       | Skip `npm install`                                                          |
+| `--force`            | Allow scaffolding into a non-empty target                                   |
+| `--help`             | Print help                                                                  |
+
+## What it creates
+
+A self-contained workspace with:
+
+- `engine/`, `src/`, `vite.config.ts` — the open-press framework (snapshot of `@open-press/core`)
+- `document/` — your content (populated from the chosen style pack)
+- `.claude/skills/` and `.agents/skills/` — agent skill files for Claude Code, Codex, Cursor, Copilot, etc.
+- `openpress.config.mjs` — workspace metadata (title, subtitle, organization, author)
+- `AGENTS.md` — agent contract
+
+## After init
+
+Workspace commands (run via `npm run` or `node engine/cli.mjs`):
+
+```
+npm run dev         # start workbench
+npm run build       # render production output (dist-react/)
+npm run preview     # preview production build
+npm run openpress:validate   # structural checks
+npm run openpress:pdf        # render PDF
+npm run openpress:deploy:dry-run
+```
+
+## License
+
+MIT — see [LICENSE](https://github.com/quan0715/open-press/blob/main/LICENSE).

package/dist/cli.js

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import process2 from "process";
+
+// src/init.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { cp, mkdir as mkdir2, readdir, rm as rm2 } from "fs/promises";
+import path2 from "path";
+import process from "process";
+import { fileURLToPath } from "url";
+
+// src/degit.ts
+import { createWriteStream } from "fs";
+import { mkdir, rm, stat } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { x as extract } from "tar";
+async function pathIsEmpty(target) {
+  try {
+    const s = await stat(target);
+    if (!s.isDirectory()) return false;
+    const { readdir: readdir2 } = await import("fs/promises");
+    const entries = await readdir2(target);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+
+// src/metadata.ts
+import { readFile, writeFile } from "fs/promises";
+async function patchOpenpressConfig(configPath, patch) {
+  let source = await readFile(configPath, "utf8");
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0 || value === null || value === "") continue;
+    const escaped = escapeStringForJs(value);
+    const re = new RegExp(`(${key}\\s*:\\s*)("[^"]*"|'[^']*'|\`[^\`]*\`)`, "m");
+    if (re.test(source)) {
+      source = source.replace(re, `$1"${escaped}"`);
+    } else {
+      source = source.replace(/(export\s+default\s*\{)/, `$1
+  ${key}: "${escaped}",`);
+    }
+  }
+  await writeFile(configPath, source);
+}
+function escapeStringForJs(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function patchPackageJsonName(packagePath, newName) {
+  const text = await readFile(packagePath, "utf8");
+  const pkg = JSON.parse(text);
+  const prevName = typeof pkg.name === "string" ? pkg.name : "";
+  pkg.name = newName;
+  pkg.version = "0.0.0";
+  pkg.private = true;
+  pkg.description = `open-press workspace: ${newName}`;
+  for (const field of [
+    "publishConfig",
+    "files",
+    "bin",
+    "main",
+    "types",
+    "exports",
+    "homepage",
+    "repository",
+    "bugs",
+    "keywords",
+    "license",
+    "author"
+  ]) {
+    delete pkg[field];
+  }
+  await writeFile(packagePath, JSON.stringify(pkg, null, 2) + "\n");
+  return prevName;
+}
+
+// src/init.ts
+var KNOWN_PACKS = ["editorial-monograph", "claude-document"];
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_ROOT = path2.resolve(__dirname, "..", "template");
+var TEMPLATE_CORE = path2.join(TEMPLATE_ROOT, "core");
+var TEMPLATE_SKILLS = path2.join(TEMPLATE_ROOT, "skills");
+async function init(options) {
+  validatePack(options.pack);
+  ensureTemplateBundled();
+  const target = path2.resolve(process.cwd(), options.target);
+  await ensureTarget(target, options.force);
+  log(`Creating open-press workspace at ${target}`);
+  log("Copying framework (engine + runtime + config)\u2026");
+  await cp(TEMPLATE_CORE, target, { recursive: true });
+  const docDest = path2.join(target, "document");
+  if (options.pack) {
+    log(`Applying style pack: ${options.pack}`);
+    await rm2(docDest, { recursive: true, force: true });
+    await mkdir2(docDest, { recursive: true });
+    const packStarter = path2.join(TEMPLATE_SKILLS, options.pack, "starter", "document");
+    if (!existsSync(packStarter)) {
+      throw new Error(`Style pack starter not found: ${packStarter}`);
+    }
+    await cp(packStarter, docDest, { recursive: true });
+  } else {
+    await mkdir2(docDest, { recursive: true });
+  }
+  log("Installing SKILL files\u2026");
+  await installSkills(target);
+  const pkgPath = path2.join(target, "package.json");
+  if (existsSync(pkgPath)) {
+    await patchPackageJsonName(pkgPath, path2.basename(target));
+  }
+  const configPath = path2.join(target, "openpress.config.mjs");
+  if (existsSync(configPath) && hasMetadata(options)) {
+    log("Writing metadata into openpress.config.mjs");
+    await patchOpenpressConfig(configPath, {
+      title: options.title,
+      subtitle: options.subtitle,
+      organization: options.organization,
+      author: options.author
+    });
+  }
+  if (options.install) {
+    log("Installing dependencies (npm install)\u2026");
+    await runInTarget(target, "npm", ["install"]);
+  } else {
+    log("Skipping npm install (--no-install)");
+  }
+  if (options.git) {
+    log("Initializing git repository\u2026");
+    try {
+      await runInTarget(target, "git", ["init"]);
+      await runInTarget(target, "git", ["add", "-A"]);
+      await runInTarget(target, "git", ["commit", "-m", "Initial commit from open-press"], { silent: true });
+    } catch {
+      log("(git not available; skipping repo init)");
+    }
+  } else {
+    log("Skipping git init (--no-git)");
+  }
+  printNextSteps(target, options);
+}
+async function installSkills(target) {
+  const skillDirs = await readdir(TEMPLATE_SKILLS, { withFileTypes: true });
+  const claudeRoot = path2.join(target, ".claude", "skills");
+  const agentsRoot = path2.join(target, ".agents", "skills");
+  await mkdir2(claudeRoot, { recursive: true });
+  await mkdir2(agentsRoot, { recursive: true });
+  for (const dir of skillDirs) {
+    if (!dir.isDirectory()) continue;
+    const source = path2.join(TEMPLATE_SKILLS, dir.name);
+    const claudeTarget = path2.join(claudeRoot, dir.name);
+    const agentsTarget = path2.join(agentsRoot, dir.name);
+    await copySkillFiles(source, claudeTarget);
+    await copySkillFiles(source, agentsTarget);
+  }
+}
+async function copySkillFiles(source, dest) {
+  await mkdir2(dest, { recursive: true });
+  const entries = await readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "starter" || entry.name === "agents") continue;
+    const from = path2.join(source, entry.name);
+    const to = path2.join(dest, entry.name);
+    await cp(from, to, { recursive: true });
+  }
+}
+function ensureTemplateBundled() {
+  if (!existsSync(TEMPLATE_CORE) || !existsSync(TEMPLATE_SKILLS)) {
+    throw new Error(
+      `Template not bundled at ${TEMPLATE_ROOT}. If running from source, run \`pnpm sync:template\` in packages/cli first.`
+    );
+  }
+}
+function validatePack(pack) {
+  if (pack === void 0) return;
+  if (!KNOWN_PACKS.includes(pack)) {
+    throw new Error(`Unknown style pack: ${pack}. Known packs: ${KNOWN_PACKS.join(", ")}`);
+  }
+}
+async function ensureTarget(target, force) {
+  if (existsSync(target)) {
+    if (force) return;
+    const empty = await pathIsEmpty(target);
+    if (!empty) {
+      throw new Error(`Target ${target} is not empty. Pass --force to scaffold into it anyway.`);
+    }
+    return;
+  }
+  await mkdir2(target, { recursive: true });
+}
+function hasMetadata(options) {
+  return Boolean(options.title || options.subtitle || options.organization || options.author);
+}
+async function runInTarget(cwd, command, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: opts.silent ? ["ignore", "ignore", "ignore"] : "inherit",
+      shell: process.platform === "win32"
+    });
+    child.once("error", reject);
+    child.once("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+function log(message) {
+  process.stdout.write(`\u25B8 ${message}
+`);
+}
+function printNextSteps(target, options) {
+  const rel = path2.relative(process.cwd(), target) || ".";
+  const lines = [
+    "",
+    "\u2713 Done! Your open-press workspace is ready.",
+    "",
+    "Next steps:",
+    `  cd ${rel}`
+  ];
+  if (!options.install) {
+    lines.push("  npm install");
+  }
+  lines.push(
+    "",
+    "  # start the workbench:",
+    "  npm run dev",
+    "",
+    "Then open the local URL printed by vite (typically http://127.0.0.1:5173/?dev=1).",
+    "",
+    "AI agent skills are installed under .claude/skills/ and .agents/skills/.",
+    "Edit content under document/chapters/, or ask your AI agent to help.",
+    ""
+  );
+  process.stdout.write(lines.join("\n"));
+}
+
+// src/cli.ts
+var HELP = `open-press \u2014 AI-first fixed-layout document workspaces.
+
+Usage:
+  npx @open-press/cli init <target> [flags]
+
+Flags:
+  --pack <name>            Style pack starter: editorial-monograph | claude-document
+  --title <s>              Document title (written to openpress.config.mjs)
+  --subtitle <s>           Document subtitle
+  --organization <s>       Organization name
+  --author <s>             Author name (defaults to git user.name)
+  --no-git                 Skip git init
+  --no-install             Skip npm install
+  --force                  Allow non-empty target
+  --help                   Show this help
+
+Examples:
+  npx @open-press/cli init my-doc --pack editorial-monograph
+  npx @open-press/cli init my-doc --pack claude-document --title "Q2 Brief" --author Quan
+`;
+async function main(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    process2.stdout.write(HELP);
+    return 0;
+  }
+  const [subcommand, ...rest] = argv;
+  if (subcommand !== "init") {
+    process2.stderr.write(`Unknown command: ${subcommand}
+
+`);
+    process2.stderr.write(HELP);
+    return 1;
+  }
+  const options = parseInitArgs(rest);
+  if (!options) {
+    process2.stderr.write(HELP);
+    return 1;
+  }
+  try {
+    await init(options);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process2.stderr.write(`open-press init failed: ${msg}
+`);
+    return 1;
+  }
+}
+function parseInitArgs(args) {
+  if (args.length === 0) {
+    process2.stderr.write("open-press init: target path is required.\n\n");
+    return null;
+  }
+  const options = {
+    target: "",
+    pack: void 0,
+    title: void 0,
+    subtitle: void 0,
+    organization: void 0,
+    author: void 0,
+    git: true,
+    install: true,
+    force: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--pack":
+        options.pack = args[++i];
+        break;
+      case "--title":
+        options.title = args[++i];
+        break;
+      case "--subtitle":
+        options.subtitle = args[++i];
+        break;
+      case "--organization":
+        options.organization = args[++i];
+        break;
+      case "--author":
+        options.author = args[++i];
+        break;
+      case "--no-git":
+        options.git = false;
+        break;
+      case "--no-install":
+        options.install = false;
+        break;
+      case "--git":
+        options.git = true;
+        break;
+      case "--install":
+        options.install = true;
+        break;
+      case "--force":
+        options.force = true;
+        break;
+      default:
+        if (arg.startsWith("--")) {
+          process2.stderr.write(`Unknown flag: ${arg}
+
+`);
+          return null;
+        }
+        if (options.target) {
+          process2.stderr.write(`Unexpected positional: ${arg}
+
+`);
+          return null;
+        }
+        options.target = arg;
+    }
+  }
+  if (!options.target) {
+    process2.stderr.write("open-press init: target path is required.\n\n");
+    return null;
+  }
+  return options;
+}
+main(process2.argv.slice(2)).then((code) => process2.exit(code)).catch((err) => {
+  process2.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}
+`);
+  process2.exit(1);
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@open-press/cli",
+  "version": "0.3.0",
+  "type": "module",
+  "description": "Scaffolder for open-press — AI-first fixed-layout document workspaces.",
+  "license": "MIT",
+  "author": "quan0715",
+  "homepage": "https://github.com/quan0715/open-press#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quan0715/open-press.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/quan0715/open-press/issues"
+  },
+  "keywords": [
+    "document",
+    "mdx",
+    "react",
+    "pdf",
+    "a4",
+    "fixed-layout",
+    "ai-first",
+    "scaffold",
+    "init",
+    "cli"
+  ],
+  "bin": {
+    "open-press": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "template",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "tar": "^7.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "tsup": "^8.5.0",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "sync:template": "node scripts/sync-template.mjs",
+    "build": "pnpm sync:template && tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}