@dawitworku/projectcli 0.2.2 → 3.0.0

package/src/index.js

@@ -28,15 +28,20 @@ try {
 const { getLanguages, getFrameworks, getGenerator } = require("./registry");
 const { runSteps } = require("./run");
 const { runAdd } = require("./add");
-const { checkBinaries } = require("./preflight");
+const { checkBinaries, getInstallHint } = require("./preflight");
 const { gitClone, removeGitFolder } = require("./remote");
 const { generateCI, generateDocker } = require("./cicd");
 const { generateDevContainer } = require("./devcontainer");
 const { generateLicense, licenseTypes } = require("./license");
 const { getDescription } = require("./descriptions");
 const { detectLanguage, detectPackageManager } = require("./detect");
-const { loadConfig } = require("./config");
+const { loadConfig, loadProjectConfig } = require("./config");
 const { runConfig } = require("./settings");
+const { runDoctor } = require("./core/doctor");
+const { runPreset } = require("./preset");
+const { getPreset } = require("./presets");
+const { runUpgrade } = require("./upgrade");
+const { runPlugin } = require("./plugin");
 
 const RUST_KEYWORDS = new Set(
   [
@@ -197,7 +202,15 @@ function splitCommand(argv) {
   if (!argv || argv.length === 0) return { cmd: "init", rest: [] };
   const first = argv[0];
   if (typeof first === "string" && !first.startsWith("-")) {
-    if (first === "init" || first === "add") {
+    if (
+      first === "init" ||
+      first === "add" ||
+      first === "config" ||
+      first === "doctor" ||
+      first === "upgrade" ||
+      first === "preset" ||
+      first === "plugin"
+    ) {
       return { cmd: first, rest: argv.slice(1) };
     }
   }
@@ -211,11 +224,22 @@ function printHelp() {
   console.log("  projectcli               # init a new project");
   console.log("  projectcli init          # init a new project");
   console.log("  projectcli add           # add libraries to current project");
+  console.log("  projectcli add ci        # add GitHub Actions CI");
+  console.log("  projectcli add docker    # add Dockerfile");
+  console.log("  projectcli add devcontainer # add VS Code devcontainer");
+  console.log("  projectcli add license   # add LICENSE");
+  console.log("  projectcli add lint      # add linter defaults");
+  console.log("  projectcli add test      # add test runner defaults");
+  console.log("  projectcli doctor        # check a repo and optionally fix");
+  console.log("  projectcli preset        # manage presets");
+  console.log("  projectcli upgrade       # upgrade configs safely");
+  console.log("  projectcli plugin        # manage plugins");
   console.log("  projectcli --list        # list all frameworks");
   console.log(
     "  projectcli --language <lang> --framework <fw> --name <project>"
   );
   console.log("  projectcli config        # configure defaults");
+  console.log("  # config files: .projectclirc or projectcli.config.json");
   console.log("");
   console.log("Flags:");
   console.log("  --help, -h       Show help");
@@ -236,6 +260,23 @@ function printHelp() {
   console.log("  --no-license     Never add LICENSE");
   console.log("  --learning       Enable learning mode (shows descriptions)");
   console.log("  --template       Clone from a Git repository URL");
+  console.log("");
+  console.log("Doctor flags:");
+  console.log("  --fix            Apply safe fixes");
+  console.log("  --json           JSON output (CI-friendly)");
+  console.log("  --ci-only        Only check CI");
+
+  console.log("");
+  console.log("Upgrade flags:");
+  console.log("  --preview        Show what would change");
+  console.log("  --only ci        Upgrade only CI templates");
+  console.log("  --only docker    Upgrade Docker templates");
+  console.log("  --only devcontainer Upgrade devcontainer templates");
+
+  console.log("");
+  console.log("Plugin commands:");
+  console.log("  projectcli plugin list");
+  console.log("  projectcli plugin install <id>");
 }
 
 const BACK = "__back__";
@@ -287,17 +328,31 @@ function filterExistingWriteFiles(steps, projectRoot) {
   return { kept, skipped };
 }
 
-function printList() {
-  for (const lang of getLanguages()) {
+function printList(effectiveConfig) {
+  for (const lang of getLanguages(effectiveConfig)) {
     console.log(`${lang}:`);
-    for (const fw of getFrameworks(lang)) {
-      const gen = getGenerator(lang, fw);
+    for (const fw of getFrameworks(lang, effectiveConfig)) {
+      const gen = getGenerator(lang, fw, effectiveConfig);
       const note = gen?.notes ? ` - ${gen.notes}` : "";
-      console.log(`  - ${fw}${note}`);
+      const stability = gen?.stability ? ` [${gen.stability}]` : "";
+      console.log(`  - ${fw}${stability}${note}`);
     }
   }
 }
 
+function formatStabilityBadge(stability) {
+  if (stability === "core") return chalk.green("✅ Core");
+  if (stability === "experimental") return chalk.yellow("⚠ Experimental");
+  if (stability === "community") return chalk.cyan("👥 Community");
+  return null;
+}
+
+function printMissingTool(bin) {
+  console.log(chalk.red(`✖ ${bin} not found`));
+  const hint = getInstallHint(bin);
+  if (hint) console.log(chalk.dim(`  → ${hint}`));
+}
+
 function showBanner() {
   console.log("");
   console.log(
@@ -340,13 +395,20 @@ async function main(options = {}) {
     console.log(readPackageVersion());
     return;
   }
+
+  // Config precedence: CLI args > project config > global config (~/.projectcli.json)
+  const userConfig = loadConfig();
+  const projectConfigInfo = loadProjectConfig(process.cwd());
+  const projectConfig = projectConfigInfo.data || {};
+  const effectiveConfig = { ...userConfig, ...projectConfig };
+
   if (args.list) {
-    printList();
+    printList(effectiveConfig);
     return;
   }
 
   if (cmd === "add") {
-    await runAdd({ prompt, argv: rest });
+    await runAdd({ prompt, argv: rest, effectiveConfig });
     return;
   }
 
@@ -355,6 +417,26 @@ async function main(options = {}) {
     return;
   }
 
+  if (cmd === "doctor") {
+    await runDoctor({ prompt, argv: rest, effectiveConfig });
+    return;
+  }
+
+  if (cmd === "preset") {
+    await runPreset({ prompt, argv: rest, effectiveConfig });
+    return;
+  }
+
+  if (cmd === "upgrade") {
+    await runUpgrade({ prompt, argv: rest });
+    return;
+  }
+
+  if (cmd === "plugin") {
+    await runPlugin({ prompt, argv: rest, effectiveConfig });
+    return;
+  }
+
   // Smart Context Detection
   if (
     cmd === "init" &&
@@ -452,7 +534,7 @@ async function main(options = {}) {
             type: "input",
             name: "author",
             message: "Author Name:",
-            default: userConfig.author || "The Authors",
+            default: effectiveConfig.author || "The Authors",
           },
         ]);
         const steps = generateLicense(process.cwd(), type, author);
@@ -495,40 +577,80 @@ async function main(options = {}) {
       chalk.dim(" (Type to search)")
   );
 
-  const languages = getLanguages();
+  const languages = getLanguages(effectiveConfig);
   if (languages.length === 0) {
     throw new Error("No languages configured.");
   }
 
-  const userConfig = loadConfig();
-
   const allowedPms = ["npm", "pnpm", "yarn", "bun"];
   let preselectedPm =
     typeof args.pm === "string" && allowedPms.includes(args.pm)
       ? args.pm
       : undefined;
 
-  if (!preselectedPm && userConfig.packageManager) {
-    if (allowedPms.includes(userConfig.packageManager)) {
-      preselectedPm = userConfig.packageManager;
+  const configuredPm =
+    typeof effectiveConfig.packageManager === "string"
+      ? effectiveConfig.packageManager
+      : undefined;
+
+  if (!preselectedPm && configuredPm) {
+    if (allowedPms.includes(configuredPm)) {
+      preselectedPm = configuredPm;
     }
   }
 
-  if (userConfig.learningMode && args.learning === false) {
+  const presetId =
+    typeof effectiveConfig.preset === "string" && effectiveConfig.preset.trim()
+      ? effectiveConfig.preset.trim()
+      : "startup";
+  const preset = getPreset(presetId, effectiveConfig);
+  const presetPm =
+    typeof preset?.defaults?.packageManager === "string"
+      ? preset.defaults.packageManager
+      : null;
+
+  if (!preselectedPm && presetPm && allowedPms.includes(presetPm)) {
+    preselectedPm = presetPm;
+  }
+
+  const learningEnabled =
+    typeof effectiveConfig.learningMode === "boolean"
+      ? effectiveConfig.learningMode
+      : typeof effectiveConfig.learning === "boolean"
+      ? effectiveConfig.learning
+      : false;
+
+  if (learningEnabled && args.learning === false) {
     args.learning = true;
   }
 
   const defaultLicenseType =
-    typeof userConfig.defaultLicense === "string" &&
-    licenseTypes.includes(userConfig.defaultLicense)
-      ? userConfig.defaultLicense
+    typeof effectiveConfig.license === "string" &&
+    licenseTypes.includes(effectiveConfig.license)
+      ? effectiveConfig.license
+      : typeof effectiveConfig.defaultLicense === "string" &&
+        licenseTypes.includes(effectiveConfig.defaultLicense)
+      ? effectiveConfig.defaultLicense
       : null;
 
   const defaultAuthor =
-    typeof userConfig.author === "string" && userConfig.author.trim()
-      ? userConfig.author.trim()
+    typeof effectiveConfig.author === "string" && effectiveConfig.author.trim()
+      ? effectiveConfig.author.trim()
       : "The Authors";
 
+  const defaultCi =
+    typeof effectiveConfig.ci === "boolean"
+      ? effectiveConfig.ci
+      : preset?.defaults?.extras?.ci === true;
+  const defaultDocker =
+    typeof effectiveConfig.docker === "boolean"
+      ? effectiveConfig.docker
+      : preset?.defaults?.extras?.docker === true;
+  const defaultDevContainer =
+    typeof effectiveConfig.devcontainer === "boolean"
+      ? effectiveConfig.devcontainer
+      : preset?.defaults?.extras?.devcontainer === true;
+
   const state = {
     template: args.template || undefined,
     language:
@@ -541,7 +663,10 @@ async function main(options = {}) {
   };
 
   if (state.language) {
-    const frameworksForLanguage = getFrameworks(state.language);
+    const frameworksForLanguage = getFrameworks(
+      state.language,
+      effectiveConfig
+    );
     state.framework =
       args.framework && frameworksForLanguage.includes(args.framework)
         ? args.framework
@@ -564,7 +689,7 @@ async function main(options = {}) {
   while (true) {
     if (step === "language") {
       const languageChoices = languages.map((lang) => {
-        const count = getFrameworks(lang).length;
+        const count = getFrameworks(lang, effectiveConfig).length;
         return { name: `${lang} (${count})`, value: lang, short: lang };
       });
 
@@ -603,15 +728,19 @@ async function main(options = {}) {
     }
 
     if (step === "framework") {
-      const frameworks = getFrameworks(state.language);
+      const frameworks = getFrameworks(state.language, effectiveConfig);
       if (frameworks.length === 0) {
         throw new Error(`No frameworks configured for ${state.language}.`);
       }
 
       const frameworkChoices = frameworks.map((fw) => {
-        const gen = getGenerator(state.language, fw);
+        const gen = getGenerator(state.language, fw, effectiveConfig);
         const note = gen?.notes ? ` — ${gen.notes}` : "";
-        return { name: `${fw}${note}`, value: fw, short: fw };
+        const badge = gen?.stability
+          ? formatStabilityBadge(gen.stability)
+          : null;
+        const badgeText = badge ? ` ${badge}` : "";
+        return { name: `${fw}${badgeText}${note}`, value: fw, short: fw };
       });
 
       const frameworkQuestion = hasAutocomplete
@@ -650,7 +779,11 @@ async function main(options = {}) {
       state.framework = answer.framework;
 
       // Preflight Checks
-      const gen = getGenerator(state.language, state.framework);
+      const gen = getGenerator(
+        state.language,
+        state.framework,
+        effectiveConfig
+      );
       if (gen && gen.check && gen.check.length > 0) {
         /* eslint-disable-next-line no-console */
         console.log(chalk.dim("\n(checking requirements...)"));
@@ -659,7 +792,7 @@ async function main(options = {}) {
 
         if (missing.length > 0) {
           console.log(chalk.red.bold("\nMissing required tools:"));
-          missing.forEach((m) => console.log(chalk.red(` - ${m.bin}`)));
+          missing.forEach((m) => printMissingTool(m.bin));
           console.log(
             chalk.yellow("You may not be able to build or run this project.\n")
           );
@@ -830,9 +963,10 @@ async function main(options = {}) {
             langArg = "JavaScript";
           if (detectedTemplate === "Java/Kotlin") langArg = "Java";
 
-          let wantCi = Boolean(args.ci);
-          let wantDocker = Boolean(args.docker);
-          let wantDevContainer = Boolean(args.devcontainer);
+          let wantCi = Boolean(args.ci) || defaultCi;
+          let wantDocker = Boolean(args.docker) || defaultDocker;
+          let wantDevContainer =
+            Boolean(args.devcontainer) || defaultDevContainer;
           let wantLicense =
             typeof args.license === "boolean"
               ? args.license
@@ -928,7 +1062,14 @@ async function main(options = {}) {
             )
           );
         } catch (err) {
-          console.error(chalk.red("\nFailed to clone template:"), err.message);
+          const message = err && err.message ? err.message : String(err);
+          console.error(chalk.red("\nFailed to clone template:"), message);
+          if (
+            /\bENOENT\b/i.test(message) ||
+            /command not found/i.test(message)
+          ) {
+            printMissingTool("git");
+          }
           process.exit(1);
         }
         return;
@@ -1020,6 +1161,11 @@ async function main(options = {}) {
         const message = err && err.message ? err.message : String(err);
         console.error(`\nError: ${message}`);
 
+        const cmdNotFound = /^Command not found:\s*(.+)$/.exec(message);
+        if (cmdNotFound && cmdNotFound[1]) {
+          printMissingTool(cmdNotFound[1].trim());
+        }
+
         const looksLikeNameIssue =
           /cannot be used as a package name|Rust keyword|keyword|Cargo\.toml/i.test(
             message
@@ -1105,9 +1251,10 @@ async function main(options = {}) {
 
       // CI/CD & Docker & DevContainer
       if (!args.dryRun) {
-        let wantCi = args.ci;
-        let wantDocker = args.docker;
-        let wantDevContainer = Boolean(args.devcontainer);
+        let wantCi = Boolean(args.ci) || defaultCi;
+        let wantDocker = Boolean(args.docker) || defaultDocker;
+        let wantDevContainer =
+          Boolean(args.devcontainer) || defaultDevContainer;
         let wantLicense =
           typeof args.license === "boolean"
             ? args.license

package/src/plugin.js

@@ -0,0 +1,140 @@
+const chalk = require("chalk");
+
+const { loadConfig, saveConfig, CONFIG_PATH } = require("./config");
+const { getEnabledPlugins, tryLoadPlugin } = require("./plugins/manager");
+
+function parsePluginArgs(argv) {
+  const out = { yes: false, dryRun: false };
+  const args = Array.isArray(argv) ? argv : [];
+  for (const a of args) {
+    if (a === "--yes" || a === "-y") out.yes = true;
+    else if (a === "--dry-run") out.dryRun = true;
+  }
+  return out;
+}
+
+function firstPositional(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  for (const a of args) {
+    if (typeof a !== "string") continue;
+    if (a.startsWith("-")) continue;
+    return a;
+  }
+  return null;
+}
+
+function secondPositional(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  let seenFirst = false;
+  for (const a of args) {
+    if (typeof a !== "string") continue;
+    if (a.startsWith("-")) continue;
+    if (!seenFirst) {
+      seenFirst = true;
+      continue;
+    }
+    return a;
+  }
+  return null;
+}
+
+function printPluginList(effectiveConfig) {
+  const enabled = getEnabledPlugins(effectiveConfig);
+
+  console.log(chalk.bold("\nPlugins:"));
+  if (enabled.length === 0) {
+    console.log(chalk.dim("(none enabled)"));
+    console.log(chalk.dim(`Config: ${CONFIG_PATH}`));
+    console.log("");
+    return;
+  }
+
+  for (const id of enabled) {
+    const loaded = tryLoadPlugin(id);
+    if (loaded.ok) {
+      console.log(`${chalk.green("✓")} ${id}`);
+    } else {
+      console.log(`${chalk.red("✗")} ${id}`);
+      console.log(chalk.dim(`  → ${loaded.error}`));
+    }
+  }
+  console.log(chalk.dim(`\nConfig: ${CONFIG_PATH}`));
+  console.log("");
+}
+
+async function runPlugin({ prompt, argv, effectiveConfig }) {
+  const flags = parsePluginArgs(argv);
+  const args = Array.isArray(argv) ? argv : [];
+
+  const sub = firstPositional(args);
+
+  if (!sub || sub === "list") {
+    printPluginList(effectiveConfig);
+    return;
+  }
+
+  if (sub === "install") {
+    const pluginId = secondPositional(args);
+    if (!pluginId) {
+      throw new Error(
+        "Missing plugin id. Example: projectcli plugin install my-company"
+      );
+    }
+
+    const cfg = loadConfig();
+    const current = Array.isArray(cfg.plugins) ? cfg.plugins : [];
+    const enabled = new Set(
+      current.map((p) => String(p || "").trim()).filter(Boolean)
+    );
+
+    if (enabled.has(pluginId)) {
+      console.log(chalk.dim(`\nAlready enabled: ${pluginId}`));
+      return;
+    }
+
+    const loaded = tryLoadPlugin(pluginId);
+    if (!loaded.ok) {
+      console.log(
+        chalk.yellow("\nNote: this command does not install packages.")
+      );
+      console.log(
+        chalk.yellow(
+          `It only enables a plugin that is already resolvable by Node: ${pluginId}`
+        )
+      );
+    }
+
+    if (flags.dryRun) {
+      console.log(chalk.bold("\nPlanned actions:"));
+      console.log(chalk.gray("- ") + chalk.yellow(`enable plugin ${pluginId}`));
+      console.log("\nDry run: nothing executed.");
+      return;
+    }
+
+    if (!flags.yes) {
+      const { ok } = await prompt([
+        {
+          type: "confirm",
+          name: "ok",
+          message: `Enable plugin ${pluginId} in ${CONFIG_PATH}?`,
+          default: true,
+        },
+      ]);
+      if (!ok) return;
+    }
+
+    enabled.add(pluginId);
+    saveConfig({ plugins: Array.from(enabled) });
+    console.log(chalk.green(`\n✓ Enabled plugin: ${pluginId}`));
+    console.log(chalk.dim(`Config: ${CONFIG_PATH}`));
+    return;
+  }
+
+  throw new Error(
+    `Unknown plugin subcommand: ${sub}. Try: projectcli plugin list | projectcli plugin install <id>`
+  );
+}
+
+module.exports = {
+  runPlugin,
+};

package/src/plugins/contributions.js

@@ -0,0 +1,101 @@
+const { getEnabledPlugins, tryLoadPlugin } = require("./manager");
+
+function loadEnabledPlugins(effectiveConfig) {
+  const enabled = getEnabledPlugins(effectiveConfig);
+  const plugins = [];
+  const errors = [];
+
+  for (const id of enabled) {
+    const res = tryLoadPlugin(id);
+    if (res.ok) {
+      plugins.push({ id, module: res.module });
+    } else {
+      errors.push({ id, error: res.error || "Failed to load plugin" });
+    }
+  }
+
+  return { plugins, errors };
+}
+
+function getPluginPresets(effectiveConfig) {
+  const { plugins } = loadEnabledPlugins(effectiveConfig);
+  const out = [];
+
+  for (const p of plugins) {
+    const mod = p.module || {};
+    const presets = mod.presets;
+    if (!presets) continue;
+
+    if (Array.isArray(presets)) {
+      for (const preset of presets) {
+        if (preset && typeof preset.id === "string") {
+          out.push({ ...preset, pluginId: p.id });
+        }
+      }
+      continue;
+    }
+
+    if (typeof presets === "object") {
+      for (const key of Object.keys(presets)) {
+        const preset = presets[key];
+        if (!preset) continue;
+        const id = typeof preset.id === "string" ? preset.id : key;
+        if (!id) continue;
+        out.push({ ...preset, id, pluginId: p.id });
+      }
+    }
+  }
+
+  return out;
+}
+
+function getPluginRegistryAdditions(effectiveConfig) {
+  const { plugins } = loadEnabledPlugins(effectiveConfig);
+  const out = [];
+
+  for (const p of plugins) {
+    const mod = p.module || {};
+    const reg = mod.registry;
+    if (!reg) continue;
+
+    // Supported shapes:
+    // 1) registry: { "Language": { "Framework": generator, ... }, ... }
+    // 2) registry: { languages: { ... } }
+    const languages =
+      reg.languages && typeof reg.languages === "object" ? reg.languages : reg;
+    if (!languages || typeof languages !== "object") continue;
+
+    out.push({ pluginId: p.id, languages });
+  }
+
+  return out;
+}
+
+function getPluginDoctorChecks(effectiveConfig) {
+  const { plugins } = loadEnabledPlugins(effectiveConfig);
+  const out = [];
+
+  for (const p of plugins) {
+    const mod = p.module || {};
+
+    const checks = Array.isArray(mod.doctorChecks)
+      ? mod.doctorChecks
+      : Array.isArray(mod.doctor?.checks)
+      ? mod.doctor.checks
+      : [];
+
+    for (const check of checks) {
+      if (!check || typeof check.id !== "string") continue;
+      out.push({ ...check, pluginId: p.id });
+    }
+  }
+
+  return out;
+}
+
+module.exports = {
+  loadEnabledPlugins,
+  getPluginPresets,
+  getPluginRegistryAdditions,
+  getPluginDoctorChecks,
+};

package/src/plugins/manager.js

@@ -0,0 +1,38 @@
+function uniqStrings(items) {
+  const out = [];
+  const seen = new Set();
+  for (const v of items || []) {
+    if (typeof v !== "string") continue;
+    const s = v.trim();
+    if (!s) continue;
+    if (seen.has(s)) continue;
+    seen.add(s);
+    out.push(s);
+  }
+  return out;
+}
+
+function getEnabledPlugins(effectiveConfig) {
+  const fromConfig = Array.isArray(effectiveConfig?.plugins)
+    ? effectiveConfig.plugins
+    : [];
+  return uniqStrings(fromConfig);
+}
+
+function tryLoadPlugin(pluginId) {
+  try {
+    // Plugins are expected to be resolvable via Node resolution.
+    // This command only enables/disables plugins in config; it does not install packages.
+    // eslint-disable-next-line global-require, import/no-dynamic-require
+    const mod = require(pluginId);
+    return { ok: true, module: mod, error: null };
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    return { ok: false, module: null, error: message };
+  }
+}
+
+module.exports = {
+  getEnabledPlugins,
+  tryLoadPlugin,
+};