@sanjay5114/cdx 1.0.0

package/bin/cdx.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+
+const path = require('path');
+
+// Handle unexpected crashes
+process.on('uncaughtException', (err) => {
+  console.error('❌ Unexpected Error:', err.message);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (err) => {
+  console.error('❌ Promise Rejection:', err.message);
+  process.exit(1);
+});
+
+try {
+  // Resolve main CLI logic
+  const cliPath = path.resolve(__dirname, '../index.js');
+
+  // Execute main CLI
+  require(cliPath);
+
+} catch (error) {
+  console.error('❌ Failed to start cdx CLI:', error.message);
+  process.exit(1);
+}

package/commands/auth.js

@@ -0,0 +1,197 @@
+"use strict";
+
+/**
+ * CDX Auth Command
+ * Handles user registration, sign-in, sign-out, and session display
+ * via Firebase Authentication REST API with secure local JWT storage.
+ */
+
+const { T, section, ok, warn, err, info, note, spinner, table, badge, ICONS, footer } = require("../lib/ui");
+const auth  = require("../lib/auth");
+const store = require("../lib/store");
+
+module.exports = async function authCommand(action) {
+  const inquirer = (await import("inquirer").catch(() => null))?.default;
+  if (!inquirer) { err("'inquirer' package is required. Run: npm install inquirer"); return; }
+
+  const apiKey = store.get("firebaseApiKey");
+
+  // ── whoami ─────────────────────────────────────────────────────────────────
+  if (action === "whoami") {
+    const user = await auth.restoreSession().catch(() => null);
+    if (!user) {
+      warn("No active session. Sign in with:  cdx auth login");
+    } else {
+      section("Active Session");
+      table([
+        ["Status",       badge("Authenticated", "success")],
+        ["Display Name", user.displayName || "—"],
+        ["Email",        user.email],
+        ["User ID",      user.uid || "—"],
+        ["Session",      badge("Valid", "success")],
+      ]);
+    }
+    footer();
+    return;
+  }
+
+  // ── logout ─────────────────────────────────────────────────────────────────
+  if (action === "logout") {
+    auth.signOut();
+    ok("Successfully signed out. Session cleared from device.");
+    footer();
+    return;
+  }
+
+  // ── Require Firebase API key for login/signup ──────────────────────────────
+  if (!apiKey) {
+    warn("Firebase API key is not configured.");
+    info("Run  cdx config  to set your Firebase Web API key first.");
+    footer();
+    return;
+  }
+
+  // ── login ──────────────────────────────────────────────────────────────────
+  if (action === "login") {
+    section("Sign In", "Firebase Authentication");
+
+    // Check for existing valid session
+    const existing = await auth.restoreSession().catch(() => null);
+    if (existing) {
+      ok(`Already signed in as ${existing.email}`);
+      note("Run  cdx auth logout  to sign out.");
+      footer();
+      return;
+    }
+
+    const { email } = await inquirer.prompt([{
+      type   : "input",
+      name   : "email",
+      message: T.brand("Email address:"),
+      prefix : `   ${T.accent(ICONS.arrow)}`,
+      validate: v => v.includes("@") || "Please enter a valid email address.",
+    }]);
+
+    const { password } = await inquirer.prompt([{
+      type   : "password",
+      name   : "password",
+      message: T.brand("Password:"),
+      mask   : "•",
+      prefix : `   ${T.accent(ICONS.arrow)}`,
+      validate: v => v.length >= 6 || "Password must be at least 6 characters.",
+    }]);
+
+    console.log();
+    const spin = spinner("Authenticating with Firebase…").start();
+
+    try {
+      const session = await auth.signIn(apiKey, email, password);
+      auth.persistSession(session);
+      spin.ok(`Welcome back, ${session.displayName}!`);
+      console.log();
+      table([
+        ["Email",        session.email],
+        ["Display Name", session.displayName],
+        ["User ID",      session.uid],
+        ["Session",      badge("Active — stored securely on device", "success")],
+      ]);
+    } catch (e) {
+      spin.fail("Authentication failed");
+      err(e.message);
+    }
+
+    footer();
+    return;
+  }
+
+  // ── signup ─────────────────────────────────────────────────────────────────
+  if (action === "signup") {
+    section("Create Account", "Firebase Authentication");
+
+    const answers = await inquirer.prompt([
+      {
+        type   : "input",
+        name   : "displayName",
+        message: T.brand("Display name:"),
+        prefix : `   ${T.accent(ICONS.arrow)}`,
+        validate: v => v.trim().length >= 2 || "Display name must be at least 2 characters.",
+      },
+      {
+        type   : "input",
+        name   : "email",
+        message: T.brand("Email address:"),
+        prefix : `   ${T.accent(ICONS.arrow)}`,
+        validate: v => v.includes("@") || "Please enter a valid email address.",
+      },
+      {
+        type   : "password",
+        name   : "password",
+        message: T.brand("Password (min. 8 characters):"),
+        mask   : "•",
+        prefix : `   ${T.accent(ICONS.arrow)}`,
+        validate: v => v.length >= 8 || "Password must be at least 8 characters.",
+      },
+      {
+        type   : "password",
+        name   : "confirm",
+        message: T.brand("Confirm password:"),
+        mask   : "•",
+        prefix : `   ${T.accent(ICONS.arrow)}`,
+        validate: (v, a) => v === a.password || "Passwords do not match.",
+      },
+    ]);
+
+    console.log();
+    const spin = spinner("Creating your account…").start();
+
+    try {
+      const session = await auth.signUp(apiKey, answers.email, answers.password, answers.displayName);
+      auth.persistSession(session);
+      spin.ok("Account created successfully!");
+      console.log();
+      table([
+        ["Display Name", session.displayName],
+        ["Email",        session.email],
+        ["User ID",      session.uid],
+        ["Session",      badge("Active — JWT stored securely on device", "success")],
+      ]);
+      note("Your session token is encrypted and stored at ~/.cdx/.session");
+    } catch (e) {
+      spin.fail("Registration failed");
+      err(e.message);
+    }
+
+    footer();
+    return;
+  }
+
+  // ── reset-password ─────────────────────────────────────────────────────────
+  if (action === "reset-password") {
+    section("Reset Password", "Firebase Authentication");
+
+    const { email } = await inquirer.prompt([{
+      type   : "input",
+      name   : "email",
+      message: T.brand("Email address:"),
+      prefix : `   ${T.accent(ICONS.arrow)}`,
+      validate: v => v.includes("@") || "Please enter a valid email address.",
+    }]);
+
+    const spin = spinner("Sending password reset email…").start();
+    try {
+      await auth.sendPasswordReset(apiKey, email);
+      spin.ok("Password reset email sent. Check your inbox.");
+    } catch (e) {
+      spin.fail("Failed to send reset email");
+      err(e.message);
+    }
+
+    footer();
+    return;
+  }
+
+  // Unknown sub-action
+  warn(`Unknown auth action: ${action}`);
+  info("Valid actions: login, signup, logout, whoami, reset-password");
+  footer();
+};

package/commands/config.js

@@ -0,0 +1,165 @@
+"use strict";
+
+const { T, section, ok, warn, info, note, spinner, table, badge, panel, ICONS, footer } = require("../lib/ui");
+const store = require("../lib/store");
+
+const CATEGORIES = [
+  { key: "ai",       label: "AI & Model Settings",       desc: "Gemini API key, model selection",      icon: "◈" },
+  { key: "firebase", label: "Firebase Authentication",   desc: "Web API key for login/signup",         icon: "◉" },
+  { key: "github",   label: "GitHub Integration",        desc: "PAT and target repository",            icon: "◆" },
+  { key: "output",   label: "Output & Formatting",       desc: "Documentation output preferences",     icon: "★" },
+  { key: "show",     label: "Show Current Config",       desc: "Display all settings (secrets masked)", icon: "ℹ" },
+  { key: "reset",    label: "Reset All Settings",        desc: "Clear all config and sessions",        icon: "⚠", danger: true },
+];
+
+const AI_MODELS = [
+  { name: "gemini-2.5-pro-preview-03-25  (Latest — highest quality)", value: "gemini-2.5-pro-preview-03-25" },
+  { name: "gemini-2.0-flash              (Fast — good for large repos)", value: "gemini-2.0-flash" },
+  { name: "gemini-1.5-pro                (Stable Pro)", value: "gemini-1.5-pro" },
+  { name: "gemini-1.5-flash              (Fast & economical)", value: "gemini-1.5-flash" },
+];
+
+function mask(val) {
+  if (!val) return T.dim("not set");
+  const s = String(val);
+  if (s.length <= 8) return T.warn("•".repeat(s.length));
+  return T.muted(s.slice(0, 4)) + T.dim("•".repeat(Math.min(s.length - 8, 20))) + T.muted(s.slice(-4));
+}
+
+module.exports = async function configCommand(category) {
+  const inquirer = (await import("inquirer").catch(() => null))?.default;
+  if (!inquirer) { warn("'inquirer' package is required."); return; }
+
+  section("Configuration Manager", "CDX Enterprise Settings");
+
+  let cat = category;
+  if (!cat) {
+    const choices = CATEGORIES.map(c => ({
+      name : `  ${c.danger ? T.warn(c.icon) : T.brand(c.icon)}  ${T.white(c.label)}  ${T.dim(c.desc)}`,
+      value: c.key,
+    }));
+    const { selected } = await inquirer.prompt([{
+      type: "list", name: "selected",
+      message: T.brand("Select configuration category:"),
+      choices, prefix: `   ${T.accent(ICONS.arrow)}`,
+    }]);
+    cat = selected;
+  }
+
+  console.log();
+
+  if (cat === "ai") {
+    section("AI & Model Settings");
+    const { apiKey } = await inquirer.prompt([{
+      type: "password", name: "apiKey",
+      message: T.brand("Gemini API key") + T.dim(" (blank to keep current):"),
+      mask: "•", prefix: `   ${T.accent(ICONS.arrow)}`,
+    }]);
+    const { model } = await inquirer.prompt([{
+      type: "list", name: "model",
+      message: T.brand("Preferred Gemini model:"),
+      choices: AI_MODELS, default: store.get("geminiModel") || AI_MODELS[0].value,
+      prefix: `   ${T.accent(ICONS.arrow)}`,
+    }]);
+    const spin = spinner("Saving AI configuration…").start();
+    await new Promise(r => setTimeout(r, 300));
+    if (apiKey?.trim()) store.set("geminiApiKey", apiKey.trim());
+    store.set("geminiModel", model);
+    spin.ok("AI configuration saved.");
+    note(`Model set to: ${model}`);
+  }
+
+  else if (cat === "firebase") {
+    section("Firebase Authentication");
+    panel([
+      T.muted("Setup instructions:"),
+      T.dim("1. Create project at console.firebase.google.com"),
+      T.dim("2. Project Settings → General → Web API Key"),
+      T.dim("3. Authentication → Sign-in method → Enable Email/Password"),
+    ], "Firebase Setup");
+    const { fbKey } = await inquirer.prompt([{
+      type: "password", name: "fbKey",
+      message: T.brand("Firebase Web API key") + T.dim(" (blank to keep):"),
+      mask: "•", prefix: `   ${T.accent(ICONS.arrow)}`,
+    }]);
+    if (fbKey?.trim()) {
+      const spin = spinner("Saving Firebase configuration…").start();
+      await new Promise(r => setTimeout(r, 300));
+      store.set("firebaseApiKey", fbKey.trim());
+      spin.ok("Firebase API key saved securely (0o600).");
+    } else { info("No changes made."); }
+  }
+
+  else if (cat === "github") {
+    section("GitHub Integration");
+    panel([
+      T.muted("Required token scopes:"),
+      T.dim("• repo — read/write repository contents"),
+      T.dim("• read:user — read profile"),
+      T.dim("Generate at: github.com/settings/tokens"),
+    ], "Token Permissions");
+    const answers = await inquirer.prompt([
+      { type: "password", name: "token", message: T.brand("GitHub PAT") + T.dim(" (blank to keep):"), mask: "•", prefix: `   ${T.accent(ICONS.arrow)}` },
+      { type: "input", name: "repo", message: T.brand("Target repo") + T.dim(` (${store.get("githubRepo") || "not set"}) owner/repo:`), prefix: `   ${T.accent(ICONS.arrow)}` },
+    ]);
+    const spin = spinner("Saving GitHub configuration…").start();
+    await new Promise(r => setTimeout(r, 300));
+    let updated = false;
+    if (answers.token?.trim()) { store.set("githubToken", answers.token.trim()); updated = true; }
+    if (answers.repo?.trim())  { store.set("githubRepo",  answers.repo.trim());  updated = true; }
+    updated ? spin.ok("GitHub configuration saved.") : spin.warn("No changes made.");
+  }
+
+  else if (cat === "output") {
+    section("Output & Formatting Preferences");
+    const answers = await inquirer.prompt([
+      { type: "list", name: "defaultFile", message: T.brand("Default output filename:"), choices: ["README.md","DOCS.md","DOCUMENTATION.md","docs/index.md"], default: store.get("defaultOutput") || "README.md", prefix: `   ${T.accent(ICONS.arrow)}` },
+      { type: "confirm", name: "autoPush", message: T.brand("Auto-push to GitHub after generation?"), default: store.get("autoPush") ?? false, prefix: `   ${T.accent(ICONS.arrow)}` },
+      { type: "confirm", name: "generateSubDocs", message: T.brand("Generate sub-documents (architecture.md, onboarding.md, etc.)?"), default: store.get("generateSubDocs") ?? true, prefix: `   ${T.accent(ICONS.arrow)}` },
+    ]);
+    const spin = spinner("Saving preferences…").start();
+    await new Promise(r => setTimeout(r, 300));
+    store.set("defaultOutput",   answers.defaultFile);
+    store.set("autoPush",        answers.autoPush);
+    store.set("generateSubDocs", answers.generateSubDocs);
+    spin.ok("Output preferences saved.");
+  }
+
+  else if (cat === "show") {
+    section("Current Configuration");
+    const cfg     = store.load();
+    const session = store.loadSession();
+    const alive   = store.sessionIsAlive(session);
+    table([
+      ["Gemini API Key",   mask(cfg.geminiApiKey)],
+      ["Gemini Model",     cfg.geminiModel     || T.dim("auto")],
+      ["Firebase API Key", mask(cfg.firebaseApiKey)],
+      ["GitHub Token",     mask(cfg.githubToken)],
+      ["GitHub Repo",      cfg.githubRepo      || T.dim("not set")],
+      ["Default Output",   cfg.defaultOutput   || T.dim("README.md")],
+      ["Auto Push",        cfg.autoPush        ? badge("ON",  "success") : badge("OFF", "default")],
+      ["Sub-documents",    cfg.generateSubDocs !== false ? badge("ON", "success") : badge("OFF", "default")],
+      ["Auth Session",     alive ? badge("Active", "success") : badge("No session", "default")],
+      ["Signed In As",     cfg.userEmail       || T.dim("not signed in")],
+      ["Config Path",      "~/.cdx/config.json  (0o600)"],
+    ]);
+  }
+
+  else if (cat === "reset") {
+    section("Reset Configuration");
+    warn("This will permanently delete all stored credentials and session tokens.");
+    const { confirm } = await inquirer.prompt([{
+      type: "confirm", name: "confirm",
+      message: T.warn("Are you absolutely sure?"),
+      default: false, prefix: `   ${T.accent(ICONS.arrow)}`,
+    }]);
+    if (confirm) {
+      const spin = spinner("Clearing all configuration…").start();
+      await new Promise(r => setTimeout(r, 500));
+      store.clear();
+      spin.ok("All settings cleared. CDX has been reset.");
+    } else { info("Reset cancelled."); }
+  }
+
+  footer();
+};