@open-press/cli 0.8.0 → 1.1.0

package/dist/cli.js

@@ -1,66 +1,29 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import { spawn as spawn2 } from "child_process";
+import { createRequire } from "module";
+import path2 from "path";
 import process2 from "process";
 
 // src/init.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
-import { cp, mkdir as mkdir2, rm as rm2 } from "fs/promises";
-import path2 from "path";
+import { mkdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path 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 degit({ owner, repo, ref = "main", dest, subdir }) {
-  const url = `https://codeload.github.com/${owner}/${repo}/tar.gz/refs/heads/${ref}`;
-  const tmpDir = await mkdir(path.join(tmpdir(), `open-press-degit-${Date.now()}`), { recursive: true });
-  const tarballPath = path.join(tmpDir, "repo.tar.gz");
-  try {
-    await fetchTo(url, tarballPath);
-    await mkdir(dest, { recursive: true });
-    const subdirSegments = subdir ? subdir.split("/").filter(Boolean).length : 0;
-    const totalStrip = 1 + subdirSegments;
-    const filterPrefix = subdir ? subdir.replace(/\/$/, "") + "/" : null;
-    await extract({
-      file: tarballPath,
-      cwd: dest,
-      strip: totalStrip,
-      filter: (filePath) => {
-        const segments = filePath.split("/");
-        const inside = segments.slice(1).join("/");
-        if (filterPrefix) {
-          return inside.startsWith(filterPrefix);
-        }
-        return true;
-      }
-    });
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true }).catch(() => {
-    });
-  }
-}
-async function fetchTo(url, destFile) {
-  const res = await fetch(url, { redirect: "follow" });
-  if (!res.ok || !res.body) {
-    throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
-  }
-  await pipeline(Readable.fromWeb(res.body), createWriteStream(destFile));
-}
-async function pathIsEmpty(target) {
+// src/path-is-empty.ts
+import { readdir, stat } from "fs/promises";
+var HARMLESS_TARGET_ENTRIES = /* @__PURE__ */ new Set([".git", ".gitignore", ".gitkeep", ".DS_Store"]);
+async function pathIsEmpty(target, options = {}) {
   try {
     const s = await stat(target);
     if (!s.isDirectory()) return false;
-    const { readdir } = await import("fs/promises");
     const entries = await readdir(target);
-    return entries.length === 0;
+    if (!options.ignoreHarmless) return entries.length === 0;
+    return entries.every((entry) => HARMLESS_TARGET_ENTRIES.has(entry));
   } catch {
     return true;
   }
@@ -68,133 +31,51 @@ async function pathIsEmpty(target) {
 
 // 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}",`);
-    }
+async function patchPressTitle(entryPath, title) {
+  const source = await readFile(entryPath, "utf8");
+  const escaped = escapeStringForJs(title);
+  const existing = /(<Press\b[^>]*\btitle\s*=\s*)("[^"]*"|'[^']*'|\{`[^`]*`\})/;
+  let next;
+  if (existing.test(source)) {
+    next = source.replace(existing, `$1"${escaped}"`);
+  } else {
+    next = source.replace(/<Press\b/, `<Press title="${escaped}"`);
   }
-  await writeFile(configPath, source);
+  await writeFile(entryPath, next);
 }
 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 BUNDLED_PACKS = ["editorial-monograph", "claude-document", "academic-paper"];
 var FRAMEWORK_SKILLS_SOURCE = "quan0715/open-press";
-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_PACKS = path2.join(TEMPLATE_ROOT, "packs");
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var CLI_PACKAGE_JSON = path.resolve(__dirname, "..", "package.json");
 async function init(options) {
-  const packSpec = options.pack ? parsePackSpec(options.pack) : null;
-  ensureTemplateBundled();
-  const target = path2.resolve(process.cwd(), options.target);
-  await ensureTarget(target, options.force);
+  const target = path.resolve(process.cwd(), options.target);
+  await ensureTarget(target);
+  const workspaceName = path.basename(target);
+  const title = options.title ?? "OpenPress Document";
+  const version = await readCliVersion();
   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");
-  await rm2(docDest, { recursive: true, force: true });
-  await mkdir2(docDest, { recursive: true });
-  if (packSpec?.kind === "bundled") {
-    log(`Applying bundled style pack: ${packSpec.name}`);
-    const packStarter = path2.join(TEMPLATE_PACKS, packSpec.name, "document");
-    if (!existsSync(packStarter)) {
-      throw new Error(`Bundled style pack starter not found: ${packStarter}`);
-    }
-    await cp(packStarter, docDest, { recursive: true });
-  } else if (packSpec?.kind === "github") {
-    log(`Fetching style pack from github:${packSpec.owner}/${packSpec.repo}${packSpec.ref ? `#${packSpec.ref}` : ""}\u2026`);
-    try {
-      await degit({
-        owner: packSpec.owner,
-        repo: packSpec.repo,
-        ref: packSpec.ref,
-        dest: docDest,
-        subdir: "starter/document"
-      });
-    } catch (err) {
-      throw new Error(
-        `Failed to fetch pack from github:${packSpec.owner}/${packSpec.repo}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (await pathIsEmpty(docDest)) {
-      throw new Error(
-        `github:${packSpec.owner}/${packSpec.repo} doesn't contain starter/document/ at the repo root.
-Third-party pack repos should follow this layout:
-  <repo>/
-  \u251C\u2500\u2500 starter/
-  \u2502   \u2514\u2500\u2500 document/   \u2190 cli copies this into your workspace's document/
-  \u2514\u2500\u2500 skills/<pack>/SKILL.md   \u2190 npx skills add picks this up`
-      );
-    }
+  await writeWorkspacePackageJson(target, workspaceName, version);
+  await writeWorkspaceGitignore(target);
+  await writeStarterPress(target, title);
+  if (options.title) {
+    const pressEntry = path.join(target, "press", "index.tsx");
+    log("Writing title into <Press> in press/index.tsx");
+    await patchPressTitle(pressEntry, options.title);
   }
-  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
-    });
-  }
-  log(`Installing framework skills via \`npx skills add ${FRAMEWORK_SKILLS_SOURCE}\`\u2026`);
-  try {
-    await runInTarget(target, "npx", ["-y", "skills@latest", "add", FRAMEWORK_SKILLS_SOURCE]);
-  } catch (err) {
-    log(`(framework skills install failed; retry: npx skills add ${FRAMEWORK_SKILLS_SOURCE})`);
-    log(`  reason: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  if (packSpec?.kind === "github") {
-    const packSource = `${packSpec.owner}/${packSpec.repo}`;
-    log(`Installing pack skills via \`npx skills add ${packSource}\`\u2026`);
+  if (options.skills) {
+    log(`Installing framework skills via \`open-press skills add\`\u2026`);
     try {
-      await runInTarget(target, "npx", ["-y", "skills@latest", "add", packSource]);
+      await runInTarget(target, "npx", ["-y", "skills@latest", "add", FRAMEWORK_SKILLS_SOURCE]);
     } catch (err) {
-      log(`(pack skills install failed; retry: npx skills add ${packSource})`);
+      log(`(framework skills install failed; retry later: open-press skills add)`);
       log(`  reason: ${err instanceof Error ? err.message : String(err)}`);
     }
+  } else {
+    log("Skipping agent skills (--no-skills)");
   }
   if (options.install) {
     log("Installing dependencies (npm install)\u2026");
@@ -216,46 +97,200 @@ Third-party pack repos should follow this layout:
   }
   printNextSteps(target, options);
 }
-function parsePackSpec(spec) {
-  if (spec.startsWith("github:")) {
-    const rest = spec.slice("github:".length);
-    const [pathPart, ref] = rest.split("#");
-    const segments = pathPart.split("/").filter(Boolean);
-    if (segments.length !== 2) {
+async function ensureTarget(target) {
+  if (existsSync(target)) {
+    const empty = await pathIsEmpty(target, { ignoreHarmless: true });
+    if (!empty) {
       throw new Error(
-        `Invalid --pack spec: "${spec}". Use github:owner/repo or github:owner/repo#ref.`
+        `Target ${target} is not empty. Remove existing files first, or scaffold into a different directory.`
       );
     }
-    const [owner, repo] = segments;
-    return { kind: "github", owner, repo, ref: ref?.trim() || void 0 };
-  }
-  if (!BUNDLED_PACKS.includes(spec)) {
-    throw new Error(
-      `Unknown style pack: "${spec}". Bundled packs: ${BUNDLED_PACKS.join(", ")}. For third-party packs use github:owner/repo (e.g. github:quan0715/openpress-pack-nycu-thesis).`
-    );
+    return;
   }
-  return { kind: "bundled", name: spec };
+  await mkdir(target, { recursive: true });
 }
-function ensureTemplateBundled() {
-  if (!existsSync(TEMPLATE_CORE) || !existsSync(TEMPLATE_PACKS)) {
-    throw new Error(
-      `Template not bundled at ${TEMPLATE_ROOT}. If running from source, run \`pnpm sync:template\` in packages/cli first.`
-    );
-  }
+async function readCliVersion() {
+  const pkg = JSON.parse(await readFile2(CLI_PACKAGE_JSON, "utf8"));
+  return typeof pkg.version === "string" && pkg.version ? pkg.version : "latest";
 }
-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.`);
+async function writeWorkspacePackageJson(target, workspaceName, version) {
+  const pkg = {
+    name: workspaceName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    description: `open-press workspace: ${workspaceName}`,
+    scripts: {
+      dev: "open-press dev . --renderer react",
+      build: "open-press render . --renderer react",
+      preview: "open-press preview . --renderer react",
+      typecheck: "open-press typecheck .",
+      "openpress:image": "open-press image .",
+      "openpress:pdf": "open-press pdf .",
+      "openpress:deploy": "open-press deploy .",
+      "openpress:deploy:dry-run": "open-press deploy . --confirm --dry-run",
+      "openpress:skills": "open-press skills update"
+    },
+    dependencies: {
+      "@open-press/core": version
+    },
+    devDependencies: {
+      "@open-press/cli": version,
+      "@types/node": "^25.8.0",
+      "@types/react": "^19.2.14",
+      "@types/react-dom": "^19.2.3",
+      typescript: "^6.0.3"
+    },
+    openpress: {
+      pdf: {
+        filename: "document.pdf"
+      },
+      deploy: {
+        adapter: "cloudflare-pages",
+        source: ".deploy/openpress",
+        projectName: null,
+        commitDirty: false,
+        requiresConfirmation: true
+      }
     }
-    return;
+  };
+  await writeFile2(path.join(target, "package.json"), `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+async function writeWorkspaceGitignore(target) {
+  const content = [
+    "node_modules/",
+    ".DS_Store",
+    "*.log",
+    "",
+    "# OpenPress generated artifacts",
+    ".openpress/",
+    ".deploy/",
+    ".turbo/",
+    "dist/",
+    "dist-react/",
+    "public/openpress/",
+    "output/",
+    ""
+  ].join("\n");
+  await writeFile2(path.join(target, ".gitignore"), content, "utf8");
+}
+async function writeStarterPress(target, title) {
+  const pressRoot = path.join(target, "press");
+  await mkdir(path.join(pressRoot, "components"), { recursive: true });
+  await mkdir(path.join(pressRoot, "media"), { recursive: true });
+  await mkdir(path.join(pressRoot, "theme", "base"), { recursive: true });
+  await mkdir(path.join(pressRoot, "theme", "page-surfaces"), { recursive: true });
+  await mkdir(path.join(pressRoot, "theme", "shell"), { recursive: true });
+  await writeFile2(path.join(pressRoot, "design.md"), `# ${title}
+
+Starter OpenPress workspace.
+`, "utf8");
+  await writeFile2(path.join(pressRoot, "media", "README.md"), "# Media\n\nPlace project media here.\n", "utf8");
+  await writeFile2(
+    path.join(pressRoot, "theme", "base", "page-contract.css"),
+    `* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  background: #181818;
+}
+
+body {
+  color: #171717;
+  font-family: var(--openpress-font-body, system-ui, sans-serif);
+  -webkit-print-color-adjust: exact;
+  print-color-adjust: exact;
+}
+
+.reader-page {
+  background: #ffffff;
+}
+`,
+    "utf8"
+  );
+  await writeFile2(
+    path.join(pressRoot, "theme", "base", "typography.css"),
+    `h1,
+h2,
+h3,
+p {
+  margin: 0;
+}
+
+h1 {
+  font-family: var(--openpress-font-serif, Georgia, serif);
+  font-size: clamp(42px, 8cqw, 72px);
+  line-height: 1;
+  font-weight: 500;
+}
+
+p {
+  font-size: clamp(16px, 2cqw, 22px);
+  line-height: 1.5;
+}
+
+code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+`,
+    "utf8"
+  );
+  await writeFile2(
+    path.join(pressRoot, "theme", "base", "print.css"),
+    `@media print {
+  html,
+  body {
+    background: #ffffff;
   }
-  await mkdir2(target, { recursive: true });
 }
-function hasMetadata(options) {
-  return Boolean(options.title || options.subtitle || options.organization || options.author);
+`,
+    "utf8"
+  );
+  await writeFile2(path.join(pressRoot, "theme", "page-surfaces", "cover.css"), "/* Starter cover surface. */\n", "utf8");
+  await writeFile2(path.join(pressRoot, "theme", "page-surfaces", "back-cover.css"), "/* Starter back-cover surface. */\n", "utf8");
+  await writeFile2(path.join(pressRoot, "theme", "page-surfaces", "toc.css"), "/* Starter TOC surface. */\n", "utf8");
+  await writeFile2(path.join(pressRoot, "theme", "shell", "reader-controls.css"), "/* Starter reader controls surface. */\n", "utf8");
+  await writeFile2(
+    path.join(pressRoot, "theme", "tokens.css"),
+    `:root {
+  --openpress-font-body: system-ui, sans-serif;
+  --openpress-font-serif: Georgia, serif;
+}
+`,
+    "utf8"
+  );
+  await writeFile2(
+    path.join(pressRoot, "index.tsx"),
+    `import { Frame, Press, Workspace } from "@open-press/core";
+
+export default function OpenPressDocument() {
+  return (
+    <Workspace name="${escapeJsxAttribute(title)}">
+      <Press title="${escapeJsxAttribute(title)}">
+        <Frame frameKey="cover" role="manuscript.cover">
+          <main style={{ padding: "72px", fontFamily: "var(--openpress-font-serif, Georgia, serif)" }}>
+            <p style={{ letterSpacing: "0.12em", textTransform: "uppercase" }}>OpenPress</p>
+            <h1>${escapeText(title)}</h1>
+            <p>Edit <code>press/index.tsx</code>, then run <code>npm run dev</code>.</p>
+          </main>
+        </Frame>
+      </Press>
+    </Workspace>
+  );
+}
+`,
+    "utf8"
+  );
+}
+function escapeJsxAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function escapeText(value) {
+  return value.replace(/{/g, "&#123;").replace(/}/g, "&#125;").replace(/</g, "&lt;");
 }
 async function runInTarget(cwd, command, args, opts = {}) {
   return new Promise((resolve, reject) => {
@@ -276,7 +311,7 @@ function log(message) {
 `);
 }
 function printNextSteps(target, options) {
-  const rel = path2.relative(process.cwd(), target) || ".";
+  const rel = path.relative(process.cwd(), target) || ".";
   const lines = [
     "",
     "\u2713 Done. Your open-press workspace is ready.",
@@ -287,6 +322,9 @@ function printNextSteps(target, options) {
   if (!options.install) {
     lines.push("  npm install");
   }
+  if (!options.skills) {
+    lines.push("  npm run openpress:skills");
+  }
   lines.push(
     "",
     "  # start the workbench:",
@@ -294,44 +332,49 @@ function printNextSteps(target, options) {
     "",
     "Then open the local URL printed by Vite (typically http://127.0.0.1:5173/?dev=1).",
     "",
-    "Agent skills installed under .agents/skills/ (universal \u2014 read by Claude Code,",
-    `Cursor, Codex, Gemini CLI, etc.). Update later with: npx skills upgrade`,
-    "",
-    "Edit content under document/chapters/, or ask your AI agent to help.",
+    "Use an OpenPress-ready skill to add or adapt the press source tree.",
     ""
   );
   process.stdout.write(lines.join("\n"));
 }
 
 // src/cli.ts
+var require2 = createRequire(import.meta.url);
 var HELP = `open-press \u2014 AI-first fixed-layout document workspaces.
 
 Usage:
-  npx @open-press/cli init <target> [flags]
+  open-press init <target> [flags]
+  open-press <command> [path] [options]
+  open-press skills <add|update> [--source <owner/repo>]
 
-Flags:
-  --pack <spec>            Style pack source. Either:
-                             \u2022 a bundled name \u2014 editorial-monograph | claude-document | academic-paper
-                             \u2022 github:owner/repo (third-party pack)
-                             \u2022 github:owner/repo#branch-or-tag
-  --title <s>              Document title (written to openpress.config.mjs)
-  --subtitle <s>           Document subtitle
-  --organization <s>       Organization name
-  --author <s>             Author name
+Init flags:
+  --title <s>              Document title (written into <Press title="..."> in press/index.tsx)
   --no-git                 Skip git init
   --no-install             Skip npm install
-  --force                  Allow non-empty target
+  --skills                 Install OpenPress agent skills after scaffolding
+  --no-skills              Skip agent skill installation
   --help                   Show this help
 
-Examples:
-  # Bundled
-  npx @open-press/cli init my-doc --pack editorial-monograph
-  npx @open-press/cli init my-brief --pack claude-document --title "Q2 Brief" --author Quan
-  npx @open-press/cli init my-paper --pack academic-paper --title "Paper Title" --author "First Author"
+Runtime commands:
+  dev                      Start the local OpenPress workbench
+  render                   Build the static reader
+  preview                  Preview the static reader
+  image                    Export pages to PNG
+  pdf                      Export pages to PDF
+  validate                 Validate source structure
+  inspect                  Inspect rendered output
+  search                   Search workspace source
+  replace                  Replace workspace source text
+  doctor                   Check package and skill freshness
+  upgrade                  Update workspace dependencies and skills
+  migrate                  Alias for upgrade
+  skills                   Install or update OpenPress agent skills
 
-  # Third-party (any GitHub repo with starter/document/ at the root)
-  npx @open-press/cli init my-thesis --pack github:quan0715/openpress-pack-nycu-thesis
-  npx @open-press/cli init my-paper --pack github:foo/their-pack#v1.2
+Examples:
+  npx @open-press/cli init my-doc
+  npx @open-press/cli init my-brief --title "Q2 Brief"
+  npx open-press dev .
+  npx open-press image .
 `;
 async function main(argv) {
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
@@ -339,27 +382,26 @@ async function main(argv) {
     return 0;
   }
   const [subcommand, ...rest] = argv;
-  if (subcommand !== "init") {
-    process2.stderr.write(`Unknown command: ${subcommand}
-
+  if (subcommand === "init") {
+    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}
 `);
-    process2.stderr.write(HELP);
-    return 1;
-  }
-  const options = parseInitArgs(rest);
-  if (!options) {
-    process2.stderr.write(HELP);
-    return 1;
+      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;
+  if (subcommand === "skills") {
+    return delegateToCore(normalizeSkillsArgs(rest));
   }
+  return delegateToCore([subcommand, ...rest]);
 }
 function parseInitArgs(args) {
   if (args.length === 0) {
@@ -368,47 +410,34 @@ function parseInitArgs(args) {
   }
   const options = {
     target: "",
-    pack: void 0,
     title: void 0,
-    subtitle: void 0,
-    organization: void 0,
-    author: void 0,
     git: true,
     install: true,
-    force: false
+    skills: 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 "--no-skills":
+        options.skills = false;
+        break;
       case "--git":
         options.git = true;
         break;
       case "--install":
         options.install = true;
         break;
-      case "--force":
-        options.force = true;
+      case "--skills":
+        options.skills = true;
         break;
       default:
         if (arg.startsWith("--")) {
@@ -432,6 +461,45 @@ function parseInitArgs(args) {
   }
   return options;
 }
+function normalizeSkillsArgs(args) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand || subcommand === "add" || subcommand === "update") {
+    return ["skills:sync", ...rest];
+  }
+  return ["skills:sync", subcommand, ...rest];
+}
+async function delegateToCore(args) {
+  const coreCli = resolveCoreCli();
+  return new Promise((resolve, reject) => {
+    const child = spawn2(process2.execPath, [coreCli, ...args], {
+      cwd: process2.cwd(),
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+}
+function resolveCoreCli() {
+  const coreEntry = require2.resolve("@open-press/core");
+  const coreRoot = findPackageRoot(coreEntry, "@open-press/core");
+  return path2.join(coreRoot, "engine", "cli.mjs");
+}
+function findPackageRoot(startPath, packageName) {
+  let dir = path2.dirname(startPath);
+  while (true) {
+    const pkgPath = path2.join(dir, "package.json");
+    try {
+      const pkg = require2(pkgPath);
+      if (pkg.name === packageName) return dir;
+    } catch {
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not find ${packageName} package root from ${startPath}`);
+    }
+    dir = parent;
+  }
+}
 main(process2.argv.slice(2)).then((code) => process2.exit(code)).catch((err) => {
   process2.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}
 `);