camelmind 0.2.2 → 0.2.3

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import path2 from "path";
-import fs2 from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import path3 from "path";
+import fs3 from "fs";
 
 // src/commands/init.ts
 import path from "path";
@@ -135,11 +135,188 @@ async function init(projectName, options) {
 `);
 }
 
-// src/commands/version.ts
+// src/commands/update.ts
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { execSync as execSync2 } from "child_process";
+import fs2 from "fs-extra";
 import chalk2 from "chalk";
 import ora2 from "ora";
+import prompts2 from "prompts";
+var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
+var TEMPLATE_DIR2 = path2.join(__dirname2, "../template");
+var FRAMEWORK_DIRS = ["app", "components", "lib", "public", "scripts"];
+var FRAMEWORK_FILES = [
+  "next.config.ts",
+  "postcss.config.mjs",
+  "tsconfig.json",
+  "eslint.config.mjs",
+  "proxy.ts"
+];
+async function walkFiles(dir) {
+  if (!await fs2.pathExists(dir)) return [];
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".next" || entry.name === ".git") {
+      continue;
+    }
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function mergePackageJson(current, template) {
+  return {
+    ...current,
+    scripts: {
+      ...template.scripts,
+      ...current.scripts
+    },
+    dependencies: {
+      ...current.dependencies,
+      ...template.dependencies
+    },
+    devDependencies: {
+      ...current.devDependencies,
+      ...template.devDependencies
+    },
+    overrides: {
+      ...current.overrides,
+      ...template.overrides
+    }
+  };
+}
+async function copyWithBackup(source, target, backupRoot, projectRoot) {
+  if (await fs2.pathExists(target)) {
+    await backupFile(target, backupRoot, projectRoot);
+  }
+  await fs2.ensureDir(path2.dirname(target));
+  await fs2.copy(source, target, { overwrite: true });
+}
+async function backupFile(file, backupRoot, projectRoot) {
+  const rel = path2.relative(projectRoot, file);
+  await fs2.ensureDir(path2.dirname(path2.join(backupRoot, rel)));
+  await fs2.copy(file, path2.join(backupRoot, rel), { overwrite: true });
+}
+async function updatePackageJson(projectRoot, backupRoot, dryRun) {
+  const projectPkgPath = path2.join(projectRoot, "package.json");
+  const templatePkgPath = path2.join(TEMPLATE_DIR2, "_package.json");
+  const current = await fs2.readJson(projectPkgPath);
+  const template = await fs2.readJson(templatePkgPath);
+  const merged = mergePackageJson(current, template);
+  if (dryRun) return;
+  await backupFile(projectPkgPath, backupRoot, projectRoot);
+  await fs2.writeJson(projectPkgPath, merged, { spaces: 2 });
+  await fs2.appendFile(projectPkgPath, "\n");
+}
+async function plannedTemplateFiles() {
+  const files = [];
+  for (const dir of FRAMEWORK_DIRS) {
+    const dirPath = path2.join(TEMPLATE_DIR2, dir);
+    const dirFiles = await walkFiles(dirPath);
+    files.push(...dirFiles.map((file) => path2.relative(TEMPLATE_DIR2, file)));
+  }
+  files.push(...FRAMEWORK_FILES);
+  return files.sort();
+}
+async function update(targetDir, options) {
+  const projectRoot = path2.resolve(process.cwd(), targetDir ?? ".");
+  const packageJsonPath = path2.join(projectRoot, "package.json");
+  const configPath = path2.join(projectRoot, "camelmind.config.ts");
+  if (!await fs2.pathExists(TEMPLATE_DIR2)) {
+    console.error(chalk2.red("Template directory not found in the installed CamelMind package."));
+    process.exit(1);
+  }
+  if (!await fs2.pathExists(packageJsonPath) || !await fs2.pathExists(configPath)) {
+    console.error(chalk2.red("Run this command from a CamelMind project root, or pass the project directory."));
+    process.exit(1);
+  }
+  const files = await plannedTemplateFiles();
+  const backupRoot = path2.join(
+    projectRoot,
+    ".camelmind-update-backup",
+    (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")
+  );
+  console.log(`
+  ${chalk2.hex("#D8A15B").bold("CamelMind update")}
+
+  Project: ${chalk2.cyan(projectRoot)}
+  Files:   ${chalk2.cyan(String(files.length))} framework files + package.json
+  Backup:  ${chalk2.cyan(path2.relative(projectRoot, backupRoot))}
+`);
+  if (options.dryRun) {
+    console.log(chalk2.bold("  Dry run \u2014 files that would be refreshed:\n"));
+    for (const file of files) console.log(`    ${file}`);
+    console.log("    package.json");
+    console.log("");
+    return;
+  }
+  if (!options.yes) {
+    const { proceed } = await prompts2(
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Refresh CamelMind framework files and merge package updates?",
+        initial: true
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    if (!proceed) {
+      console.log(chalk2.gray("\n  Update cancelled.\n"));
+      return;
+    }
+  }
+  const spinner = ora2("Refreshing CamelMind framework files...").start();
+  try {
+    for (const rel of files) {
+      await copyWithBackup(
+        path2.join(TEMPLATE_DIR2, rel),
+        path2.join(projectRoot, rel),
+        backupRoot,
+        projectRoot
+      );
+    }
+    await updatePackageJson(projectRoot, backupRoot, false);
+    spinner.succeed("CamelMind files refreshed");
+  } catch (err) {
+    spinner.fail("Update failed");
+    console.error(chalk2.red(`
+  ${String(err)}
+`));
+    process.exit(1);
+  }
+  if (options.install) {
+    const installSpinner = ora2("Installing updated dependencies...").start();
+    try {
+      execSync2("npm install", {
+        cwd: projectRoot,
+        stdio: "ignore"
+      });
+      installSpinner.succeed("Dependencies installed");
+    } catch {
+      installSpinner.warn("Dependency install failed \u2014 run npm install inside your project");
+    }
+  }
+  console.log(`
+  ${chalk2.green("Done.")} Review the changes, then run:
+
+    ${chalk2.cyan("npm run lint")}
+    ${chalk2.cyan("npm run build")}
+
+  Backup saved in ${chalk2.cyan(path2.relative(projectRoot, backupRoot))}
+`);
+}
+
+// src/commands/version.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
 async function checkVersion(currentVersion) {
-  const spinner = ora2("Checking latest version...").start();
+  const spinner = ora3("Checking latest version...").start();
   let latestVersion;
   try {
     const res = await fetch("https://registry.npmjs.org/camelmind/latest");
@@ -150,7 +327,7 @@ async function checkVersion(currentVersion) {
   } catch {
     spinner.fail("Could not reach the npm registry");
     console.log(`
-  Installed: ${chalk2.cyan(currentVersion)}
+  Installed: ${chalk3.cyan(currentVersion)}
 `);
     return;
   }
@@ -158,28 +335,29 @@ async function checkVersion(currentVersion) {
   const [latMajor, latMinor, latPatch] = latestVersion.split(".").map(Number);
   const isOutdated = latMajor > curMajor || latMajor === curMajor && latMinor > curMinor || latMajor === curMajor && latMinor === curMinor && latPatch > curPatch;
   console.log(`
-  Installed  ${chalk2.cyan(currentVersion)}
-  Latest     ${isOutdated ? chalk2.yellow(latestVersion) : chalk2.green(latestVersion)}
+  Installed  ${chalk3.cyan(currentVersion)}
+  Latest     ${isOutdated ? chalk3.yellow(latestVersion) : chalk3.green(latestVersion)}
 `);
   if (isOutdated) {
     console.log(
-      `  ${chalk2.yellow("\u26A0")}  A new version is available. Run:
+      `  ${chalk3.yellow("\u26A0")}  A new version is available. To update an existing site, run:
 
-    ${chalk2.cyan("npm install -g camelmind@latest")}
+    ${chalk3.cyan("npx camelmind@latest update")}
 `
     );
   } else {
-    console.log(`  ${chalk2.green("\u2713")}  You're up to date.
+    console.log(`  ${chalk3.green("\u2713")}  You're up to date.
 `);
   }
 }
 
 // src/index.ts
-var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
-var pkgPath = path2.join(__dirname2, "../package.json");
-var pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+var __dirname3 = path3.dirname(fileURLToPath3(import.meta.url));
+var pkgPath = path3.join(__dirname3, "../package.json");
+var pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
 var program = new Command();
 program.name("camelmind").description("CamelMind CLI \u2014 scaffold and manage documentation sites").version(pkg.version);
 program.command("init [project-name]").description("Create a new CamelMind documentation site").option("--no-install", "Skip installing npm dependencies").action(init);
 program.command("version").description("Show installed version and check for updates").action(() => checkVersion(pkg.version));
+program.command("update [project-dir]").description("Update an existing CamelMind site to the latest platform files").option("--no-install", "Skip installing npm dependencies").option("--dry-run", "Show what would change without writing files").option("-y, --yes", "Skip the confirmation prompt").action(update);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camelmind",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Create and manage CamelMind documentation sites",
   "license": "MIT",
   "type": "module",

package/template/_package.json

@@ -25,6 +25,10 @@
     "rehype-slug": "^6.0.0",
     "remark-gfm": "^4.0.1"
   },
+  "overrides": {
+    "js-yaml": "^4.2.0",
+    "postcss": "^8.5.10"
+  },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
     "@types/js-yaml": "^4.0.9",