@mohasinac/cli 0.1.0

package/dist/chunk-32Q3MIAS.js

@@ -0,0 +1,72 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-N3ETBM74.js";
+
+// src/next.ts
+var ALWAYS_TRANSPILE = [
+  "@mohasinac/contracts",
+  "@mohasinac/core",
+  "@mohasinac/react",
+  "@mohasinac/ui",
+  "@mohasinac/http",
+  "@mohasinac/next",
+  "@mohasinac/tokens",
+  "@mohasinac/css-tailwind",
+  "@mohasinac/css-vanilla"
+];
+var FEATURE_PACKAGE_MAP = {
+  layout: "@mohasinac/feat-layout",
+  forms: "@mohasinac/feat-forms",
+  filters: "@mohasinac/feat-filters",
+  media: "@mohasinac/feat-media",
+  auth: "@mohasinac/feat-auth",
+  account: "@mohasinac/feat-account",
+  products: "@mohasinac/feat-products",
+  categories: "@mohasinac/feat-categories",
+  cart: "@mohasinac/feat-cart",
+  wishlist: "@mohasinac/feat-wishlist",
+  checkout: "@mohasinac/feat-checkout",
+  orders: "@mohasinac/feat-orders",
+  payments: "@mohasinac/feat-payments",
+  blog: "@mohasinac/feat-blog",
+  reviews: "@mohasinac/feat-reviews",
+  faq: "@mohasinac/feat-faq",
+  search: "@mohasinac/feat-search",
+  homepage: "@mohasinac/feat-homepage",
+  admin: "@mohasinac/feat-admin",
+  events: "@mohasinac/feat-events",
+  auctions: "@mohasinac/feat-auctions",
+  promotions: "@mohasinac/feat-promotions",
+  seller: "@mohasinac/feat-seller",
+  stores: "@mohasinac/feat-stores",
+  "pre-orders": "@mohasinac/feat-pre-orders",
+  consultation: "@mohasinac/feat-consultation",
+  corporate: "@mohasinac/feat-corporate",
+  "before-after": "@mohasinac/feat-before-after",
+  loyalty: "@mohasinac/feat-loyalty",
+  collections: "@mohasinac/feat-collections",
+  preorders: "@mohasinac/feat-preorders",
+  "whatsapp-bot": "@mohasinac/feat-whatsapp-bot"
+};
+function resolveTranspilePackages(features) {
+  const featurePackages = Object.entries(features).filter(([, enabled]) => enabled).map(([key]) => FEATURE_PACKAGE_MAP[key]).filter((pkg) => pkg !== void 0);
+  return [...ALWAYS_TRANSPILE, ...featurePackages];
+}
+function withFeatures(features) {
+  return function applyFeatures(nextConfig) {
+    var _a;
+    const fromFeatures = resolveTranspilePackages(features);
+    const existing = (_a = nextConfig.transpilePackages) != null ? _a : [];
+    const merged = [
+      ...fromFeatures,
+      ...existing.filter((p) => !fromFeatures.includes(p))
+    ];
+    return __spreadProps(__spreadValues({}, nextConfig), { transpilePackages: merged });
+  };
+}
+
+export {
+  resolveTranspilePackages,
+  withFeatures
+};

package/dist/chunk-N3ETBM74.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+export {
+  __spreadValues,
+  __spreadProps
+};

package/dist/chunk-TH6TQLJH.js

@@ -0,0 +1,86 @@
+import {
+  __spreadValues
+} from "./chunk-N3ETBM74.js";
+
+// src/i18n.ts
+var _dynamicImport = new Function(
+  "modulePath",
+  "return import(modulePath)"
+);
+var FEATURE_NAMESPACE_MAP = {
+  layout: "layout",
+  forms: "forms",
+  auth: "auth",
+  account: "account",
+  products: "products",
+  categories: "categories",
+  cart: "cart",
+  wishlist: "wishlist",
+  checkout: "checkout",
+  orders: "orders",
+  payments: "payments",
+  blog: "blog",
+  reviews: "reviews",
+  faq: "faq",
+  search: "search",
+  homepage: "home",
+  admin: "admin",
+  events: "events",
+  auctions: "auctions",
+  promotions: "promotions",
+  seller: "seller",
+  stores: "stores",
+  "pre-orders": "preOrders",
+  consultation: "consultation",
+  concern: "concern",
+  corporate: "corporate",
+  "before-after": "beforeAfter",
+  loyalty: "loyalty",
+  collections: "collections",
+  preorders: "preorders"
+};
+function deepMerge(a, b) {
+  const result = __spreadValues({}, a);
+  for (const key of Object.keys(b)) {
+    const av = a[key];
+    const bv = b[key];
+    if (bv !== null && typeof bv === "object" && !Array.isArray(bv) && av !== null && typeof av === "object" && !Array.isArray(av)) {
+      result[key] = deepMerge(av, bv);
+    } else {
+      result[key] = bv;
+    }
+  }
+  return result;
+}
+async function tryLoadFeatureMessages(featureKey, locale) {
+  var _a;
+  try {
+    const pkg = `@mohasinac/feat-${featureKey}`;
+    const mod = await _dynamicImport(`${pkg}/messages/${locale}.json`);
+    return (_a = mod.default) != null ? _a : mod;
+  } catch (e) {
+    return {};
+  }
+}
+async function mergeFeatureMessages(locale, features) {
+  var _a;
+  let projectMessages = {};
+  try {
+    const mod = await _dynamicImport(`../../messages/${locale}.json`);
+    projectMessages = (_a = mod.default) != null ? _a : mod;
+  } catch (e) {
+  }
+  const enabledKeys = Object.entries(features).filter(([key, enabled]) => enabled && key in FEATURE_NAMESPACE_MAP).map(([key]) => key);
+  const fragments = await Promise.all(
+    enabledKeys.map((key) => tryLoadFeatureMessages(key, locale))
+  );
+  let base = {};
+  for (const fragment of fragments) {
+    base = deepMerge(base, fragment);
+  }
+  return deepMerge(base, projectMessages);
+}
+
+export {
+  mergeFeatureMessages
+};

package/dist/cli.cjs

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/cli.ts
+var import_commander4 = require("commander");
+
+// src/commands/add.ts
+var import_commander = require("commander");
+var import_path2 = require("path");
+
+// src/utils.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function findProjectRoot(cwd = process.cwd()) {
+  var _a, _b;
+  let dir = cwd;
+  while (true) {
+    const pkgPath = (0, import_path.join)(dir, "package.json");
+    if ((0, import_fs.existsSync)(pkgPath)) {
+      try {
+        const pkg = JSON.parse((0, import_fs.readFileSync)(pkgPath, "utf-8"));
+        const deps = __spreadValues(__spreadValues({}, (_a = pkg.dependencies) != null ? _a : {}), (_b = pkg.devDependencies) != null ? _b : {});
+        if ("next" in deps) return dir;
+      } catch (e) {
+      }
+    }
+    const parent = (0, import_path.dirname)(dir);
+    if (parent === dir)
+      throw new Error("Could not find Next.js project root from: " + cwd);
+    dir = parent;
+  }
+}
+async function loadManifest(name, projectRoot) {
+  const monoSrcPath = (0, import_path.join)(
+    projectRoot,
+    "packages",
+    `feat-${name}`,
+    "src",
+    "manifest.ts"
+  );
+  const monoJsPath = (0, import_path.join)(
+    projectRoot,
+    "packages",
+    `feat-${name}`,
+    "dist",
+    "esm",
+    "manifest.js"
+  );
+  const pkgPath = (0, import_path.join)(
+    projectRoot,
+    "node_modules",
+    "@mohasinac",
+    `feat-${name}`,
+    "dist",
+    "esm",
+    "manifest.js"
+  );
+  const tryPaths = [monoJsPath, pkgPath];
+  let mod = null;
+  for (const p of tryPaths) {
+    if ((0, import_fs.existsSync)(p)) {
+      mod = await import(
+        /* @vite-ignore */
+        `file://${p}`
+      );
+      break;
+    }
+  }
+  if (!mod) {
+    if ((0, import_fs.existsSync)(monoSrcPath)) {
+      mod = await import(
+        /* @vite-ignore */
+        `file://${monoSrcPath}`
+      );
+    }
+  }
+  if (!(mod == null ? void 0 : mod.manifest)) {
+    throw new Error(
+      `Cannot find manifest for @mohasinac/feat-${name}. Tried:
+  ${tryPaths.join("\n  ")}`
+    );
+  }
+  return mod.manifest;
+}
+function generateRouteStub(stub, featureName) {
+  const { default: def, generateMetadata: gm } = stub.exports;
+  const named = gm ? `{ ${def} as default, ${gm} }` : `{ ${def} as default }`;
+  return `// Auto-generated by @mohasinac/cli \u2014 do not edit
+export ${named} from "@mohasinac/feat-${featureName}";
+`;
+}
+function generateApiRouteStub(stub, featureName) {
+  const methods = stub.methods.join(", ");
+  const segment = stub.segment;
+  return `// Auto-generated by @mohasinac/cli \u2014 do not edit
+export { ${methods} } from "@mohasinac/feat-${featureName}/${segment}";
+`;
+}
+function writeStub(filePath, content) {
+  if ((0, import_fs.existsSync)(filePath)) return "skipped";
+  (0, import_fs.mkdirSync)((0, import_path.dirname)(filePath), { recursive: true });
+  (0, import_fs.writeFileSync)(filePath, content, "utf-8");
+  return "created";
+}
+function patchFeaturesConfig(projectRoot, featureKey, value) {
+  const candidates = [
+    (0, import_path.join)(projectRoot, "features.config.ts"),
+    (0, import_path.join)(projectRoot, "features.config.js")
+  ];
+  const configPath = candidates.find(import_fs.existsSync);
+  if (!configPath) {
+    console.warn("  \u26A0  features.config.ts not found \u2014 skipping config patch");
+    return;
+  }
+  let source = (0, import_fs.readFileSync)(configPath, "utf-8");
+  const valueStr = String(value);
+  const existingPattern = new RegExp(
+    `(\\b${featureKey}\\s*:\\s*)(true|false)`,
+    "g"
+  );
+  if (existingPattern.test(source)) {
+    source = source.replace(existingPattern, `$1${valueStr}`);
+  } else {
+    source = source.replace(
+      /(}\s*satisfies\s*FeaturesConfig)/,
+      `  ${featureKey}: ${valueStr},
+$1`
+    );
+  }
+  (0, import_fs.writeFileSync)(configPath, source, "utf-8");
+}
+function patchEnvExample(projectRoot, envKeys) {
+  if (envKeys.length === 0) return;
+  const envPath = (0, import_path.join)(projectRoot, ".env.example");
+  const existing = (0, import_fs.existsSync)(envPath) ? (0, import_fs.readFileSync)(envPath, "utf-8") : "";
+  const missing = envKeys.filter((k) => !existing.includes(k));
+  if (missing.length === 0) return;
+  const block = "\n# Added by @mohasinac/cli\n" + missing.map((k) => `${k}=`).join("\n") + "\n";
+  (0, import_fs.writeFileSync)(envPath, existing + block, "utf-8");
+}
+
+// src/commands/add.ts
+function addCommand() {
+  const cmd = new import_commander.Command("add");
+  cmd.description("Add a @mohasinac/feat-<name> feature to the project").argument("<name>", "Feature name, e.g. events").option("-r, --root <path>", "Project root (default: auto-detect)").option("--dry-run", "Print what would be created without writing files").action(async (name, opts) => {
+    var _a, _b;
+    const projectRoot = (_a = opts.root) != null ? _a : findProjectRoot();
+    const dryRun = (_b = opts.dryRun) != null ? _b : false;
+    console.log(`
+  Adding @mohasinac/feat-${name}...
+`);
+    let manifest;
+    try {
+      manifest = await loadManifest(name, projectRoot);
+    } catch (err) {
+      console.error(`  \u2717 ${err.message}`);
+      process.exit(1);
+    }
+    for (const route of manifest.routes) {
+      const stubPath = (0, import_path2.join)(projectRoot, "app", route.segment, "page.tsx");
+      const content = generateRouteStub(route, name);
+      if (dryRun) {
+        console.log(
+          `  [dry-run] would create: app/${route.segment}/page.tsx`
+        );
+      } else {
+        const result = writeStub(stubPath, content);
+        const icon = result === "created" ? "\u2714" : "\u2013";
+        const label = result === "created" ? "created" : "already exists";
+        console.log(`  ${icon}  app/${route.segment}/page.tsx  \u2192 ${label}`);
+      }
+    }
+    for (const route of manifest.apiRoutes) {
+      const stubPath = (0, import_path2.join)(projectRoot, "app", route.segment, "route.ts");
+      const content = generateApiRouteStub(route, name);
+      if (dryRun) {
+        console.log(
+          `  [dry-run] would create: app/${route.segment}/route.ts`
+        );
+      } else {
+        const result = writeStub(stubPath, content);
+        const icon = result === "created" ? "\u2714" : "\u2013";
+        const label = result === "created" ? "created" : "already exists";
+        console.log(`  ${icon}  app/${route.segment}/route.ts  \u2192 ${label}`);
+      }
+    }
+    if (!dryRun) {
+      patchFeaturesConfig(projectRoot, name, true);
+      console.log(`  \u2714  features.config.ts  \u2192 ${name}: true`);
+    } else {
+      console.log(
+        `  [dry-run] would patch: features.config.ts \u2192 ${name}: true`
+      );
+    }
+    if (manifest.envKeys.length > 0) {
+      if (!dryRun) {
+        patchEnvExample(projectRoot, manifest.envKeys);
+        console.log(`  \u2714  .env.example  \u2192 ${manifest.envKeys.join(", ")}`);
+      } else {
+        console.log(
+          `  [dry-run] would add to .env.example: ${manifest.envKeys.join(", ")}`
+        );
+      }
+    }
+    console.log(`
+  Done.
+`);
+  });
+  return cmd;
+}
+
+// src/commands/remove.ts
+var import_commander2 = require("commander");
+var import_fs2 = require("fs");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var AUTO_GEN_MARKER = "// @mohasinac-generated";
+function removeCommand() {
+  const cmd = new import_commander2.Command("remove");
+  cmd.alias("rm").description("Remove a @mohasinac/feat-<name> feature from the project").argument("<name>", "Feature name, e.g. events").option("-r, --root <path>", "Project root (default: auto-detect)").option("--dry-run", "Print what would be removed without touching files").action(async (name, opts) => {
+    var _a, _b;
+    const projectRoot = (_a = opts.root) != null ? _a : findProjectRoot();
+    const dryRun = (_b = opts.dryRun) != null ? _b : false;
+    console.log(`
+  Removing @mohasinac/feat-${name}...
+`);
+    let manifest;
+    try {
+      manifest = await loadManifest(name, projectRoot);
+    } catch (err) {
+      console.error(`  \u2717 ${err.message}`);
+      process.exit(1);
+    }
+    for (const route of manifest.routes) {
+      const stubPath = (0, import_path3.join)(projectRoot, "app", route.segment, "page.tsx");
+      deleteIfGenerated(stubPath, dryRun, `app/${route.segment}/page.tsx`);
+    }
+    for (const route of manifest.apiRoutes) {
+      const stubPath = (0, import_path3.join)(projectRoot, "app", route.segment, "route.ts");
+      deleteIfGenerated(stubPath, dryRun, `app/${route.segment}/route.ts`);
+    }
+    if (!dryRun) {
+      patchFeaturesConfig(projectRoot, name, false);
+      console.log(`  \u2714  features.config.ts  \u2192 ${name}: false`);
+    } else {
+      console.log(
+        `  [dry-run] would patch: features.config.ts \u2192 ${name}: false`
+      );
+    }
+    console.log(`
+  Done.
+`);
+  });
+  return cmd;
+}
+function deleteIfGenerated(filePath, dryRun, label) {
+  if (!(0, import_fs2.existsSync)(filePath)) {
+    console.log(`  \u2013  ${label}  \u2192 not found, skipping`);
+    return;
+  }
+  const content = (0, import_fs3.readFileSync)(filePath, "utf8");
+  if (!content.includes(AUTO_GEN_MARKER)) {
+    console.log(`  \u2013  ${label}  \u2192 hand-edited, keeping`);
+    return;
+  }
+  if (dryRun) {
+    console.log(`  [dry-run] would delete: ${label}`);
+    return;
+  }
+  (0, import_fs2.rmSync)(filePath);
+  console.log(`  \u2714  ${label}  \u2192 deleted`);
+}
+
+// src/commands/list.ts
+var import_commander3 = require("commander");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var KNOWN_FEATURES = [
+  "auth",
+  "products",
+  "categories",
+  "events",
+  "orders",
+  "bookings",
+  "reviews",
+  "promotions",
+  "blog",
+  "sellers",
+  "search",
+  "notifications",
+  "analytics",
+  "media"
+];
+function listCommand() {
+  const cmd = new import_commander3.Command("list");
+  cmd.alias("ls").description("List all @mohasinac/feat-* features and their enabled state").option("-r, --root <path>", "Project root (default: auto-detect)").option("--enabled-only", "Show only enabled features").action((opts) => {
+    var _a;
+    const projectRoot = (_a = opts.root) != null ? _a : findProjectRoot();
+    const configPath = (0, import_path4.join)(
+      projectRoot,
+      "src",
+      "config",
+      "features.config.ts"
+    );
+    const altConfigPath = (0, import_path4.join)(projectRoot, "features.config.ts");
+    const resolvedPath = (0, import_fs4.existsSync)(configPath) ? configPath : (0, import_fs4.existsSync)(altConfigPath) ? altConfigPath : null;
+    const parsed = {};
+    if (resolvedPath) {
+      const source = (0, import_fs4.readFileSync)(resolvedPath, "utf8");
+      const kvRe = /(\w+)\s*:\s*(true|false)/g;
+      let m;
+      while ((m = kvRe.exec(source)) !== null) {
+        parsed[m[1]] = m[2] === "true";
+      }
+    }
+    const allKeys = Array.from(
+      /* @__PURE__ */ new Set([...KNOWN_FEATURES, ...Object.keys(parsed)])
+    ).sort();
+    const rows = allKeys.map((key) => {
+      var _a2;
+      return {
+        key,
+        enabled: (_a2 = parsed[key]) != null ? _a2 : false,
+        pkg: `@mohasinac/feat-${key}`
+      };
+    }).filter((r) => !opts.enabledOnly || r.enabled);
+    if (rows.length === 0) {
+      console.log("\n  No features found.\n");
+      return;
+    }
+    console.log();
+    console.log(
+      "  Feature              Package                        State"
+    );
+    console.log(
+      "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+    );
+    for (const { key, pkg, enabled } of rows) {
+      const state = enabled ? "\u2714 enabled" : "  disabled";
+      const paddedKey = key.padEnd(20);
+      const paddedPkg = pkg.padEnd(30);
+      console.log(`  ${paddedKey} ${paddedPkg} ${state}`);
+    }
+    console.log();
+    if (!resolvedPath) {
+      console.log(
+        "  \u2139  No features.config.ts found \u2014 run 'mohasinac add <name>' to create one."
+      );
+      console.log();
+    }
+  });
+  return cmd;
+}
+
+// src/cli.ts
+var program = new import_commander4.Command();
+program.name("mohasinac").description("@mohasinac/* feature library CLI").version("0.1.0");
+program.addCommand(addCommand());
+program.addCommand(removeCommand());
+program.addCommand(listCommand());
+program.parse(process.argv);

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node