@dawitworku/projectcli 0.2.1 → 3.0.0

package/src/license.js

@@ -0,0 +1,80 @@
+const licenses = {
+  MIT: (year, author) => `MIT License
+
+Copyright (c) ${year} ${author}
+
+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 OR OTHER DEALINGS IN THE
+SOFTWARE.
+`,
+  Apache2: (year, author) => `                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright ${year} ${author}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+`,
+  ISC: (year, author) => `ISC License
+
+Copyright (c) ${year}, ${author}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+`,
+};
+
+function getLicense(type, author) {
+  const year = new Date().getFullYear();
+  const template = licenses[type] || licenses.MIT;
+  return template(year, author || "The Authors");
+}
+
+function generateLicense(projectRoot, type, author) {
+  return [
+    {
+      type: "writeFile",
+      path: "LICENSE",
+      content: getLicense(type, author),
+    },
+  ];
+}
+
+module.exports = {
+  getLicense,
+  generateLicense,
+  licenseTypes: ["MIT", "Apache2", "ISC"],
+};

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,
+};

package/src/preflight.js

@@ -1,5 +1,30 @@
 const { spawn } = require("node:child_process");
 
+function getInstallHint(binary) {
+  const bin = String(binary || "").toLowerCase();
+  if (bin === "git") return "Install Git: https://git-scm.com/downloads";
+  if (bin === "node" || bin === "npm")
+    return "Install Node.js (includes npm): https://nodejs.org/en/download";
+  if (bin === "pnpm") return "Install pnpm: https://pnpm.io/installation";
+  if (bin === "yarn")
+    return "Install Yarn: https://yarnpkg.com/getting-started/install";
+  if (bin === "bun") return "Install Bun: https://bun.sh/docs/installation";
+  if (bin === "cargo" || bin === "rustc")
+    return "Install Rust: https://rustup.rs";
+  if (bin === "go") return "Install Go: https://go.dev/dl/";
+  if (bin === "python" || bin === "python3")
+    return "Install Python: https://www.python.org/downloads/";
+  if (bin === "poetry")
+    return "Install Poetry: https://python-poetry.org/docs/#installation";
+  if (bin === "php") return "Install PHP: https://www.php.net/downloads";
+  if (bin === "dotnet")
+    return "Install .NET SDK: https://dotnet.microsoft.com/download";
+  if (bin === "java" || bin === "javac")
+    return "Install a JDK: https://adoptium.net/";
+  if (bin === "dart") return "Install Dart SDK: https://dart.dev/get-dart";
+  return null;
+}
+
 function checkBinary(binary, args = ["--version"]) {
   return new Promise((resolve) => {
     const child = spawn(binary, args, {
@@ -22,4 +47,5 @@ function checkBinaries(binaries) {
 module.exports = {
   checkBinary,
   checkBinaries,
+  getInstallHint,
 };

package/src/preset.js

@@ -0,0 +1,59 @@
+const chalk = require("chalk");
+
+const { loadConfig, saveConfig, CONFIG_PATH } = require("./config");
+const { listPresets, getPreset } = require("./presets");
+
+function printPresetList(effectiveConfig) {
+  console.log(chalk.bold("\nPresets:"));
+  for (const id of listPresets(effectiveConfig)) {
+    const p = getPreset(id, effectiveConfig);
+    console.log(`- ${p.id}: ${chalk.dim(p.label)}`);
+  }
+  console.log("");
+}
+
+async function runPreset({ prompt, argv, effectiveConfig }) {
+  const args = Array.isArray(argv) ? argv : [];
+  const sub = args[0];
+
+  if (!sub || sub === "list") {
+    printPresetList(effectiveConfig);
+    return;
+  }
+
+  if (sub === "use") {
+    const presetArg = args[1];
+    const preset = getPreset(presetArg, effectiveConfig);
+
+    const config = loadConfig();
+
+    if (!presetArg) {
+      const { picked } = await prompt([
+        {
+          type: "list",
+          name: "picked",
+          message: "Choose a preset:",
+          choices: listPresets(effectiveConfig),
+          default: config.preset || preset.id,
+        },
+      ]);
+      saveConfig({ preset: picked });
+      console.log(chalk.green(`\n✓ Preset set to: ${picked}`));
+      console.log(chalk.dim(`Config: ${CONFIG_PATH}`));
+      return;
+    }
+
+    saveConfig({ preset: preset.id });
+    console.log(chalk.green(`\n✓ Preset set to: ${preset.id}`));
+    console.log(chalk.dim(`Config: ${CONFIG_PATH}`));
+    return;
+  }
+
+  throw new Error(
+    `Unknown preset subcommand: ${sub}. Try: projectcli preset list | projectcli preset use <name>`
+  );
+}
+
+module.exports = {
+  runPreset,
+};

package/src/presets/index.js

@@ -0,0 +1,124 @@
+const PRESETS = {
+  minimal: {
+    id: "minimal",
+    label: "Minimal",
+    defaults: {
+      packageManager: null,
+      js: {
+        formatter: false,
+        linter: false,
+        tests: false,
+      },
+      extras: {
+        ci: false,
+        docker: false,
+        devcontainer: false,
+        license: true,
+      },
+    },
+  },
+
+  startup: {
+    id: "startup",
+    label: "Startup",
+    defaults: {
+      packageManager: "pnpm",
+      js: {
+        formatter: true,
+        linter: true,
+        tests: true,
+      },
+      extras: {
+        ci: true,
+        docker: true,
+        devcontainer: false,
+        license: true,
+      },
+    },
+  },
+
+  strict: {
+    id: "strict",
+    label: "Strict",
+    defaults: {
+      packageManager: "pnpm",
+      js: {
+        formatter: true,
+        linter: true,
+        tests: true,
+      },
+      extras: {
+        ci: true,
+        docker: true,
+        devcontainer: true,
+        license: true,
+      },
+    },
+  },
+
+  enterprise: {
+    id: "enterprise",
+    label: "Enterprise",
+    defaults: {
+      packageManager: "pnpm",
+      js: {
+        formatter: true,
+        linter: true,
+        tests: true,
+      },
+      extras: {
+        ci: true,
+        docker: true,
+        devcontainer: true,
+        license: true,
+      },
+    },
+  },
+};
+
+const { getPluginPresets } = require("../plugins/contributions");
+
+function getAllPresets(effectiveConfig) {
+  const out = { ...PRESETS };
+
+  const pluginPresets = getPluginPresets(effectiveConfig);
+  for (const p of pluginPresets) {
+    if (!p || typeof p.id !== "string") continue;
+    const id = p.id.trim().toLowerCase();
+    if (!id) continue;
+    // Plugin presets can extend the catalog; do not override built-ins.
+    if (out[id]) continue;
+
+    out[id] = {
+      id,
+      label: typeof p.label === "string" ? p.label : id,
+      defaults: p.defaults && typeof p.defaults === "object" ? p.defaults : {},
+      pluginId: p.pluginId,
+    };
+  }
+
+  return out;
+}
+
+function listPresets(effectiveConfig) {
+  return Object.keys(getAllPresets(effectiveConfig));
+}
+
+function getPreset(presetId, effectiveConfig) {
+  const all = getAllPresets(effectiveConfig);
+  if (typeof presetId !== "string") return all.startup || PRESETS.startup;
+  const key = presetId.trim().toLowerCase();
+  return all[key] || all.startup || PRESETS.startup;
+}
+
+function describePreset(presetId, effectiveConfig) {
+  const p = getPreset(presetId, effectiveConfig);
+  return { id: p.id, label: p.label, defaults: p.defaults };
+}
+
+module.exports = {
+  PRESETS,
+  listPresets,
+  getPreset,
+  describePreset,
+};

package/src/registry/index.js

@@ -0,0 +1,91 @@
+// V3 registry wrapper.
+// Combines the legacy built-in registry with plugin-provided generators.
+
+const legacy = require("../registry_legacy");
+const { getPluginRegistryAdditions } = require("../plugins/contributions");
+
+function normalizeLanguageName(name) {
+  return String(name || "").trim();
+}
+
+function normalizeFrameworkName(name) {
+  return String(name || "").trim();
+}
+
+function getPluginRegistryMap(effectiveConfig) {
+  const additions = getPluginRegistryAdditions(effectiveConfig);
+  const out = {};
+
+  for (const add of additions) {
+    const languages = add.languages;
+    if (!languages || typeof languages !== "object") continue;
+
+    for (const langKey of Object.keys(languages)) {
+      const langName = normalizeLanguageName(langKey);
+      if (!langName) continue;
+
+      const frameworks = languages[langKey];
+      if (!frameworks || typeof frameworks !== "object") continue;
+
+      if (!out[langName]) out[langName] = {};
+
+      for (const fwKey of Object.keys(frameworks)) {
+        const fwName = normalizeFrameworkName(fwKey);
+        if (!fwName) continue;
+        const gen = frameworks[fwKey];
+        if (!gen) continue;
+
+        // Do not override existing plugin framework entries.
+        if (!out[langName][fwName]) {
+          out[langName][fwName] = gen;
+        }
+      }
+    }
+  }
+
+  return out;
+}
+
+function getLanguages(effectiveConfig) {
+  const base = legacy.getLanguages();
+  const pluginMap = getPluginRegistryMap(effectiveConfig);
+
+  const extra = Object.keys(pluginMap);
+  const merged = [...base];
+  for (const lang of extra) {
+    if (!merged.includes(lang)) merged.push(lang);
+  }
+
+  return merged;
+}
+
+function getFrameworks(language, effectiveConfig) {
+  const lang = normalizeLanguageName(language);
+  const base = legacy.getFrameworks(lang);
+  const pluginMap = getPluginRegistryMap(effectiveConfig);
+  const pluginFrameworks = pluginMap[lang] ? Object.keys(pluginMap[lang]) : [];
+
+  const merged = [...base];
+  for (const fw of pluginFrameworks) {
+    if (!merged.includes(fw)) merged.push(fw);
+  }
+
+  return merged;
+}
+
+function getGenerator(language, framework, effectiveConfig) {
+  const lang = normalizeLanguageName(language);
+  const fw = normalizeFrameworkName(framework);
+
+  const base = legacy.getGenerator(lang, fw);
+  if (base) return base;
+
+  const pluginMap = getPluginRegistryMap(effectiveConfig);
+  return pluginMap[lang]?.[fw] || null;
+}
+
+module.exports = {
+  getLanguages,
+  getFrameworks,
+  getGenerator,
+};