larats 1.0.2 → 1.1.1

package/dist/index.js

@@ -3,6 +3,8 @@
 // src/index.ts
 import fs3 from "fs";
 import path4 from "path";
+import os2 from "os";
+import { exec } from "child_process";
 import { parseArgs } from "util";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
@@ -69,7 +71,7 @@ async function detectProjectType(targetDir = process.cwd()) {
       summary
     };
   }
-  if (hasTsConfig && hasPackageJson) {
+  if (hasPackageJson) {
     const pkg = readJsonSafe(packageJsonPath);
     const allDeps = {
       ...pkg?.dependencies || {},
@@ -91,13 +93,15 @@ async function detectProjectType(targetDir = process.cwd()) {
     const hasSrc = fs.existsSync(path.join(resolvedDir, "src"));
     const srcDir = hasSrc ? "src" : ".";
     const isModular = fs.existsSync(path.join(resolvedDir, srcDir, "modules")) || fs.existsSync(path.join(resolvedDir, "modules"));
-    const extras = [framework !== "node-vanilla" ? framework : "TypeScript"];
+    const isTypeScript = hasTsConfig || "typescript" in allDeps;
+    const stackLabel = isTypeScript ? "TypeScript" : "JavaScript / Node.js";
+    const extras = [framework !== "node-vanilla" ? framework : stackLabel];
     if (hasPrisma) extras.push("Prisma");
     if (hasTypeORM) extras.push("TypeORM");
     if (hasDrizzle) extras.push("Drizzle");
     if (isMonorepo) extras.push("Monorepo");
     if (isModular) extras.push("Modular");
-    const summary = `TypeScript (${extras.join(", ")})`;
+    const summary = isTypeScript ? `TypeScript (${extras.join(", ")})` : `JavaScript / Node.js (${extras.join(", ")})`;
     return {
       type: "typescript",
       name: pkg?.name || dirName,
@@ -109,7 +113,8 @@ async function detectProjectType(targetDir = process.cwd()) {
         hasDrizzle,
         isMonorepo,
         isModular,
-        srcDir
+        srcDir,
+        isTypeScript
       },
       summary
     };
@@ -505,7 +510,7 @@ ${f}`;
 }
 function mermaidLabel(str, maxLen = 40) {
   if (!str) return "";
-  let cleaned = str.replace(/"/g, "'").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/`/g, "'").replace(/[\r\n]+/g, " ").trim();
+  let cleaned = str.replace(/"/g, "'").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/`/g, "'").replace(/[\[\]\(\)\{\}]/g, "").replace(/[\r\n]+/g, " ").trim();
   if (cleaned.length > maxLen) {
     cleaned = cleaned.slice(0, maxLen - 3) + "...";
   }
@@ -908,6 +913,312 @@ ${fence(directoryTree || "(Empty directory structure)", "text")}
 ${securityNotice}
 `;
 }
+function renderTerminalFlow(scanResult) {
+  const { projectInfo, components } = scanResult;
+  const steps = [];
+  if (projectInfo.type === "laravel") {
+    steps.push("Client");
+    const routes = components["Routes"]?.count ?? 0;
+    if (routes > 0) steps.push(`Routes [${routes}]`);
+    const requests = components["Form Requests"]?.count ?? 0;
+    if (requests > 0) steps.push(`Requests [${requests}]`);
+    const controllers = components["Controllers"]?.count ?? 0;
+    if (controllers > 0) steps.push(`Controllers [${controllers}]`);
+    const services = (components["Services"]?.count ?? 0) + (components["Actions"]?.count ?? 0);
+    if (services > 0) steps.push(`Services [${services}]`);
+    const models = components["Models"]?.count ?? 0;
+    if (models > 0) steps.push(`Models [${models}]`);
+    steps.push("Database");
+  } else if (projectInfo.type === "typescript") {
+    const hasAnyLayer = ["Controllers", "Services", "Repositories", "Routes", "DTOs & Schemas", "Models & Entities", "UI Components"].some((k) => (components[k]?.count ?? 0) > 0);
+    if (hasAnyLayer) {
+      steps.push("Client");
+      const ui = components["UI Components"]?.count ?? 0;
+      if (ui > 0) steps.push(`UI [${ui}]`);
+      const routes = components["Routes"]?.count ?? 0;
+      if (routes > 0) steps.push(`Router [${routes}]`);
+      const dtos = components["DTOs & Schemas"]?.count ?? 0;
+      if (dtos > 0) steps.push(`DTOs [${dtos}]`);
+      const controllers = components["Controllers"]?.count ?? 0;
+      if (controllers > 0) steps.push(`Controllers [${controllers}]`);
+      const services = components["Services"]?.count ?? 0;
+      if (services > 0) steps.push(`Services [${services}]`);
+      const data = (components["Repositories"]?.count ?? 0) + (components["Models & Entities"]?.count ?? 0);
+      if (data > 0) steps.push(`Data Layer [${data}]`);
+      steps.push("Database");
+    } else {
+      const src = components["Source Files"]?.count ?? 0;
+      const tests = components["Test Files"]?.count ?? 0;
+      steps.push("CLI / Entrypoint");
+      if (src > 0) steps.push(`Source Modules [${src}]`);
+      if (tests > 0) steps.push(`Test Suites [${tests}]`);
+    }
+  } else {
+    const src = components["Source Files"]?.count ?? 0;
+    const tests = components["Test Files"]?.count ?? 0;
+    steps.push("Project Root");
+    if (src > 0) steps.push(`Source [${src}]`);
+    if (tests > 0) steps.push(`Tests [${tests}]`);
+  }
+  return steps.join(" \u2500\u2500> ");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function generateArchitectureHtml(scanResult) {
+  const { projectInfo, totalFilesScanned, components, modules, directoryTree } = scanResult;
+  const mermaid = generateMermaidDiagram(scanResult);
+  const componentRowsHtml = Object.entries(components).map(([, comp]) => {
+    const samples = comp.files.slice(0, 3).map((f) => `<code>${escapeHtml(f)}</code>`).join(", ");
+    const more = comp.files.length > 3 ? ` <span class="muted">(+${comp.files.length - 3} more)</span>` : "";
+    return `<tr>
+        <td><strong>${escapeHtml(comp.name)}</strong></td>
+        <td><span class="badge">${comp.count}</span></td>
+        <td>${escapeHtml(comp.description)}</td>
+        <td>${samples ? samples + more : "-"}</td>
+      </tr>`;
+  }).join("\n");
+  const modulesHtml = modules.length > 0 ? `<div class="card">
+        <h2>\u{1F4E6} Detected Modules & Domains (${modules.length})</h2>
+        <div class="modules-grid">
+          ${modules.map((m) => `<div class="module-item"><code>${escapeHtml(m)}</code></div>`).join("\n")}
+        </div>
+      </div>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>LaraTS Architecture: ${escapeHtml(projectInfo.name)}</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --card-bg: #1e293b;
+      --text: #f8fafc;
+      --muted: #94a3b8;
+      --border: #334155;
+      --primary: #38bdf8;
+      --accent: #818cf8;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      background: var(--bg);
+      color: var(--text);
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      line-height: 1.5;
+      padding: 2rem 1rem;
+    }
+    .container { max-width: 1080px; margin: 0 auto; }
+    header { margin-bottom: 2rem; border-bottom: 1px solid var(--border); padding-bottom: 1.5rem; }
+    .header-top { display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 1rem; }
+    h1 { font-size: 1.8rem; font-weight: 700; color: #fff; }
+    .pill { background: #0284c7; color: #fff; padding: 0.25rem 0.75rem; border-radius: 9999px; font-size: 0.85rem; font-weight: 600; }
+    .subtitle { color: var(--muted); margin-top: 0.5rem; font-size: 0.95rem; }
+    .card { background: var(--card-bg); border: 1px solid var(--border); border-radius: 8px; padding: 1.5rem; margin-bottom: 2rem; }
+    h2 { font-size: 1.25rem; font-weight: 600; margin-bottom: 1rem; color: #e2e8f0; }
+    table { width: 100%; border-collapse: collapse; margin-top: 0.5rem; font-size: 0.9rem; }
+    th, td { text-align: left; padding: 0.75rem 1rem; border-bottom: 1px solid var(--border); }
+    th { color: var(--muted); font-size: 0.8rem; text-transform: uppercase; letter-spacing: 0.05em; }
+    .badge { background: #334155; padding: 0.2rem 0.6rem; border-radius: 4px; font-weight: 600; font-size: 0.85rem; }
+    code { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; background: #090d16; padding: 0.15rem 0.4rem; border-radius: 4px; font-size: 0.85rem; color: #38bdf8; }
+    pre { background: #090d16; padding: 1rem; border-radius: 6px; overflow-x: auto; font-size: 0.85rem; border: 1px solid var(--border); line-height: 1.4; }
+    .mermaid-box { display: flex; justify-content: center; background: #090d16; border-radius: 8px; padding: 2rem 1rem; overflow-x: auto; border: 1px solid var(--border); }
+    .modules-grid { display: flex; flex-wrap: wrap; gap: 0.5rem; }
+    .module-item { background: #090d16; border: 1px solid var(--border); border-radius: 6px; padding: 0.5rem 1rem; }
+    .muted { color: var(--muted); font-size: 0.85rem; }
+    footer { text-align: center; color: var(--muted); font-size: 0.85rem; margin-top: 3rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <div class="header-top">
+        <div>
+          <h1>\u{1F3DB}\uFE0F Architecture Overview: ${escapeHtml(projectInfo.name)}</h1>
+          <p class="subtitle">Stack: <strong>${escapeHtml(projectInfo.summary)}</strong> &bull; Total Files: <strong>${totalFilesScanned}</strong></p>
+        </div>
+        <span class="pill">LaraTS Architecture Map</span>
+      </div>
+    </header>
+
+    <div class="card">
+      <h2>\u{1F5FA}\uFE0F Interactive Architecture Flowchart</h2>
+      <div class="mermaid-box">
+        <pre class="mermaid">${mermaid}</pre>
+      </div>
+    </div>
+
+    <div class="card">
+      <h2>\u{1F4CA} Architectural Component Statistics</h2>
+      <table>
+        <thead>
+          <tr>
+            <th>Component Layer</th>
+            <th>Files</th>
+            <th>Description</th>
+            <th>Sample Files</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${componentRowsHtml || '<tr><td colspan="4">No architectural components detected</td></tr>'}
+        </tbody>
+      </table>
+    </div>
+
+    ${modulesHtml}
+
+    <div class="card">
+      <h2>\u{1F332} Directory Structure Tree</h2>
+      <pre><code>${escapeHtml(directoryTree || "(Empty directory)")}</code></pre>
+    </div>
+
+    <footer>
+      Generated locally &amp; offline with \u2764\uFE0F by <strong>LaraTS CLI</strong>
+    </footer>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <script>
+    if (typeof mermaid !== 'undefined') {
+      mermaid.initialize({
+        startOnLoad: true,
+        theme: 'dark',
+        flowchart: { curve: 'basis' }
+      });
+    }
+  </script>
+</body>
+</html>`;
+}
+
+// src/generator/ai-context.ts
+var AI_RULES_START_TAG = "<!-- larats-rules:start -->";
+var AI_RULES_END_TAG = "<!-- larats-rules:end -->";
+function generateAiContext(scanResult) {
+  const { projectInfo, components, modules } = scanResult;
+  const lines = [];
+  lines.push("# Codebase Architecture Rules");
+  lines.push(`> Project: ${projectInfo.name} | Stack: ${projectInfo.summary}`);
+  lines.push("");
+  lines.push("## Architectural Boundaries & Principles");
+  lines.push("- Maintain strict separation of concerns across active architectural layers.");
+  lines.push("- Keep Controllers thin: handle HTTP requests, invoke Services, and return responses.");
+  lines.push("- Encapsulate all business rules, calculations, and mutations inside Services/Actions.");
+  lines.push("- Isolate data storage and queries to Repositories or Model entities.");
+  lines.push("- Validate all incoming user inputs with dedicated DTOs or Form Requests before reaching domain logic.");
+  lines.push("");
+  lines.push("## Project Structure & Layer Conventions");
+  if (projectInfo.type === "laravel") {
+    const isModular = Boolean(projectInfo.laravel?.isModular);
+    const modDir = projectInfo.laravel?.modulesDir || "app/Modules";
+    if (isModular) {
+      lines.push(`- **Architecture Style**: Modular Domain Architecture`);
+      lines.push(`- **Module Root**: \`${modDir}/<FeatureName>/\``);
+      lines.push(`- **Controllers**: \`${modDir}/<FeatureName>/Controllers/\` (HTTP handlers)`);
+      lines.push(`- **Services / Actions**: \`${modDir}/<FeatureName>/Services/\` or \`Actions/\` (Business logic)`);
+      lines.push(`- **Models**: \`${modDir}/<FeatureName>/Models/\` (Eloquent entities)`);
+      lines.push(`- **Validation**: \`${modDir}/<FeatureName>/Requests/\` (FormRequest classes)`);
+      lines.push(`- **Routes**: \`${modDir}/<FeatureName>/routes.php\` or root \`routes/\``);
+    } else {
+      lines.push(`- **Architecture Style**: Standard Laravel Layered Architecture`);
+      lines.push(`- **Controllers**: \`app/Http/Controllers/\``);
+      lines.push(`- **Services / Actions**: \`app/Services/\` or \`app/Actions/\``);
+      lines.push(`- **Models**: \`app/Models/\``);
+      lines.push(`- **Validation**: \`app/Http/Requests/\``);
+      lines.push(`- **Routes**: \`routes/web.php\`, \`routes/api.php\``);
+      lines.push(`- **Migrations**: \`database/migrations/\``);
+    }
+    if (projectInfo.laravel?.hasFilament) {
+      lines.push(`- **Admin Panel**: Filament Resources live in \`app/Filament/Resources/\``);
+    }
+  } else if (projectInfo.type === "typescript") {
+    const isModular = Boolean(projectInfo.typescript?.isModular);
+    const srcDir = projectInfo.typescript?.srcDir || "src";
+    const orm = projectInfo.typescript?.hasPrisma ? "Prisma" : projectInfo.typescript?.hasTypeORM ? "TypeORM" : projectInfo.typescript?.hasDrizzle ? "Drizzle" : null;
+    if (isModular) {
+      lines.push(`- **Architecture Style**: Feature Module Architecture`);
+      lines.push(`- **Module Root**: \`${srcDir}/modules/<feature>/\``);
+      lines.push(`- **Controllers**: \`${srcDir}/modules/<feature>/<feature>.controller.ts\``);
+      lines.push(`- **Services**: \`${srcDir}/modules/<feature>/<feature>.service.ts\``);
+      lines.push(`- **Repositories**: \`${srcDir}/modules/<feature>/<feature>.repository.ts\``);
+      lines.push(`- **DTOs / Schemas**: \`${srcDir}/modules/<feature>/<feature>.dto.ts\``);
+      lines.push(`- **Routes**: \`${srcDir}/modules/<feature>/<feature>.routes.ts\``);
+      lines.push(`- **Module Index**: \`${srcDir}/modules/<feature>/index.ts\` (barrel export)`);
+    } else {
+      lines.push(`- **Architecture Style**: Layered Architecture`);
+      lines.push(`- **Controllers**: \`${srcDir}/controllers/\``);
+      lines.push(`- **Services**: \`${srcDir}/services/\``);
+      lines.push(`- **Repositories / Data**: \`${srcDir}/repositories/\``);
+      lines.push(`- **DTOs / Schemas**: \`${srcDir}/dtos/\` or \`${srcDir}/schemas/\``);
+      lines.push(`- **Routes**: \`${srcDir}/routes/\``);
+    }
+    if (orm) {
+      lines.push(`- **Database ORM**: ${orm} is used for data persistence.`);
+    }
+  } else {
+    lines.push(`- **Source Code**: \`src/\``);
+    lines.push(`- **Automated Tests**: \`tests/\``);
+  }
+  if (modules.length > 0) {
+    lines.push("");
+    lines.push(`## Active Feature Modules (${modules.length})`);
+    lines.push(`Existing domains: ${modules.map((m) => `\`${m}\``).join(", ")}`);
+    lines.push("When creating new features, follow this established domain partition.");
+  }
+  lines.push("");
+  lines.push("## AI Coding Guardrails");
+  lines.push("1. NEVER place raw queries or database transactions inside Controller files.");
+  lines.push("2. When implementing a new feature, always create cohesive layers: Route -> Controller -> Service -> Repository/Model.");
+  lines.push("3. Keep naming conventions consistent with existing files in the repository.");
+  lines.push("4. Write automated unit/feature tests for new domain services.");
+  return lines.join("\n");
+}
+function mergeAiRules(existingContent, newRules) {
+  const block = `${AI_RULES_START_TAG}
+${newRules}
+${AI_RULES_END_TAG}`;
+  if (!existingContent || existingContent.trim() === "") {
+    return block + "\n";
+  }
+  const regex = new RegExp(`${AI_RULES_START_TAG}[\\s\\S]*?${AI_RULES_END_TAG}`, "m");
+  if (regex.test(existingContent)) {
+    return existingContent.replace(regex, block);
+  }
+  return existingContent.trimEnd() + "\n\n" + block + "\n";
+}
+
+// src/utils/clipboard.ts
+import { spawn } from "child_process";
+async function copyToClipboard(text2) {
+  const platform = process.platform;
+  let command;
+  let args = [];
+  if (platform === "win32") {
+    command = "clip";
+  } else if (platform === "darwin") {
+    command = "pbcopy";
+  } else {
+    command = process.env.WAYLAND_DISPLAY ? "wl-copy" : "xclip";
+    if (command === "xclip") {
+      args = ["-selection", "clipboard"];
+    }
+  }
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"] });
+      child.on("error", () => {
+        resolve(false);
+      });
+      child.on("close", (code) => {
+        resolve(code === 0);
+      });
+      child.stdin.write(text2);
+      child.stdin.end();
+    } catch {
+      resolve(false);
+    }
+  });
+}
 
 // src/generator/scaffolder.ts
 import fs2 from "fs";
@@ -1850,7 +2161,7 @@ async function scaffoldModule(projectInfo, options) {
 }
 
 // src/index.ts
-var VERSION = true ? "1.0.2" : "1.0.1";
+var VERSION = true ? "1.1.1" : "1.1.1";
 function showHelp() {
   console.log(`
 ${pc.bold(pc.cyan("LaraTS CLI"))} ${pc.gray(`v${VERSION}`)}
@@ -1862,19 +2173,26 @@ ${pc.bold("USAGE:")}
 
 ${pc.bold("COMMANDS:")}
   ${pc.green("scan")}                 Scan repository & generate ARCHITECTURE.md
+  ${pc.green("view")}, ${pc.green("preview")}          Open interactive architecture diagram in local browser
+  ${pc.green("ai")}                   Export architecture context prompt for AI (Cursor, Claude, Copilot)
   ${pc.green("scaffold")}, ${pc.green("make")} [name] Scaffold a new module or feature with clean boilerplate
   ${pc.green("info")}                 Show detected project type & architectural flavor
   ${pc.green("help")}                 Display this help message
 
 ${pc.bold("OPTIONS:")}
-  ${pc.yellow("-o, --output")} <file>    Output markdown path for scan (default: ARCHITECTURE.md)
+  ${pc.yellow("-o, --output")} <file>    Output path for scan (default: ARCHITECTURE.md)
+  ${pc.yellow("--view")}                 Open local browser viewer immediately after scanning
+  ${pc.yellow("--copy")}                 Copy AI architecture context prompt to clipboard
+  ${pc.yellow("--cursor")}               Inject architecture rules into .cursorrules
+  ${pc.yellow("--claude")}               Inject architecture rules into CLAUDE.md
+  ${pc.yellow("-t, --tree")}             Print directory tree in terminal
+  ${pc.yellow("--html")}                 Also export standalone ARCHITECTURE.html
   ${pc.yellow("-m, --modular")}          Enforce modular directory structure
   ${pc.yellow("-s, --standard")}         Enforce standard/layered directory structure
   ${pc.yellow("--dry-run")}              Simulate generation without writing files
   ${pc.yellow("-f, --force")}            Overwrite files if they already exist
   ${pc.yellow("-v, --version")}          Display CLI version
   ${pc.yellow("-h, --help")}             Display this help message
-
 ${pc.bold("EXAMPLES:")}
   ${pc.cyan("$")} larats
   ${pc.cyan("$")} larats scan
@@ -1887,6 +2205,113 @@ function handleCancel() {
   p.cancel(pc.yellow("Operation cancelled. See you next time! \u{1F44B}"));
   process.exit(0);
 }
+async function checkAndPromptStar(customStatsPath, forceAnswer) {
+  try {
+    const configDir = path4.join(os2.homedir(), ".larats");
+    const statsFile = customStatsPath || path4.join(configDir, "stats.json");
+    if (!fs3.existsSync(path4.dirname(statsFile))) {
+      fs3.mkdirSync(path4.dirname(statsFile), { recursive: true });
+    }
+    let stats = {};
+    if (fs3.existsSync(statsFile)) {
+      stats = JSON.parse(fs3.readFileSync(statsFile, "utf-8"));
+    }
+    const runs = (stats.runs || 0) + 1;
+    stats.runs = runs;
+    if (runs >= 3 && !stats.hasPromptedStar) {
+      stats.hasPromptedStar = true;
+      const repoUrl = "https://github.com/SidiqFatuh187/larats-cli";
+      if (process.stdin.isTTY || typeof forceAnswer === "boolean") {
+        const shouldStar = typeof forceAnswer === "boolean" ? forceAnswer : await p.confirm({
+          message: "\u2B50 Enjoying LaraTS? Would you like to support the project with a star on GitHub?",
+          initialValue: true
+        });
+        if (shouldStar && !p.isCancel(shouldStar)) {
+          openViewer(repoUrl);
+          p.log.success(pc.green("Thank you so much for your support! \u2B50 Opening GitHub repository in your browser..."));
+        } else {
+          p.log.message(pc.gray("No problem, enjoy building with LaraTS! \u{1F44D}"));
+        }
+      } else {
+        console.log(
+          `
+${pc.yellow("\u2B50 Enjoying LaraTS?")} If you find this CLI useful, please consider giving it a star on GitHub:
+   ${pc.bold(pc.cyan("\u{1F449} " + repoUrl))}
+`
+        );
+      }
+    }
+    fs3.writeFileSync(statsFile, JSON.stringify(stats, null, 2), "utf-8");
+  } catch {
+  }
+}
+function openViewer(destination) {
+  const startCmd = process.platform === "win32" ? `start "" "${destination}"` : process.platform === "darwin" ? `open "${destination}"` : `xdg-open "${destination}"`;
+  try {
+    exec(startCmd, (err) => {
+      if (err) {
+        p.log.warn(`Could not open browser automatically. Please open ${pc.cyan(destination)} manually.`);
+      }
+    });
+  } catch {
+    p.log.warn(`Could not open browser automatically. Please open ${pc.cyan(destination)} manually.`);
+  }
+}
+async function runAi(projectInfo, options = {}) {
+  const spinner2 = p.spinner();
+  spinner2.start("Scanning codebase & formulating AI architecture context...");
+  try {
+    const scanResult = await scanProject(projectInfo);
+    spinner2.stop(pc.green(`Architecture context ready (${scanResult.scanDurationMs}ms)`));
+    const aiContext = generateAiContext(scanResult);
+    let handled = false;
+    if (options.cursor) {
+      const cursorPath = path4.resolve(projectInfo.rootPath, ".cursorrules");
+      const existing = fs3.existsSync(cursorPath) ? fs3.readFileSync(cursorPath, "utf-8") : "";
+      const updated = mergeAiRules(existing, aiContext);
+      fs3.writeFileSync(cursorPath, updated, "utf-8");
+      p.log.success(pc.green(`\u2714 Architecture rules injected into ${pc.bold(".cursorrules")}`));
+      handled = true;
+    }
+    if (options.claude) {
+      const claudePath = path4.resolve(projectInfo.rootPath, "CLAUDE.md");
+      const existing = fs3.existsSync(claudePath) ? fs3.readFileSync(claudePath, "utf-8") : "";
+      const updated = mergeAiRules(existing, aiContext);
+      fs3.writeFileSync(claudePath, updated, "utf-8");
+      p.log.success(pc.green(`\u2714 Architecture rules injected into ${pc.bold("CLAUDE.md")}`));
+      handled = true;
+    }
+    if (options.copy) {
+      const copied = await copyToClipboard(aiContext);
+      if (copied) {
+        p.log.success(pc.green("\u2714 Architecture context copied to clipboard! Ready to paste into ChatGPT or Claude."));
+      } else {
+        p.log.warn("Could not access system clipboard. Printing prompt to console instead.");
+        console.log(`
+${aiContext}
+`);
+      }
+      handled = true;
+    }
+    if (!handled) {
+      console.log(`
+${pc.bold(pc.cyan("--- AI Codebase Architecture Prompt ---"))}
+${aiContext}
+${pc.bold(pc.cyan("---------------------------------------"))}
+`);
+      p.note(
+        `Tip: Run with ${pc.yellow("--copy")} to copy directly to clipboard,
+or ${pc.yellow("--cursor")} / ${pc.yellow("--claude")} to inject into rules files automatically!`,
+        pc.green("Prompt Ready for AI \u{1F916}")
+      );
+    }
+    p.outro(pc.cyan("Done!"));
+  } catch (err) {
+    spinner2.stop(pc.red("Failed to generate AI context"));
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}
 async function runScan(projectInfo, outputPath = "ARCHITECTURE.md", options = {}) {
   const spinner2 = p.spinner();
   spinner2.start("Scanning codebase structure & components (strict ignore list active)...");
@@ -1915,15 +2340,25 @@ To protect user files from accidental overwrites, use --force to overwrite.`
     const scanResult = await scanProject(projectInfo);
     const nonZeroLayers = Object.values(scanResult.components).filter((c) => c.count > 0).length;
     const totalComponents = Object.values(scanResult.components).reduce((sum, c) => sum + c.count, 0);
+    const terminalFlow = renderTerminalFlow(scanResult);
     if (options.dryRun) {
       spinner2.stop(pc.green(`Scan completed in ${scanResult.scanDurationMs}ms (dry run)`));
       p.note(
-        `${pc.bold("Scanned Files:")} ${scanResult.totalFilesScanned}
+        `${pc.bold("Architecture Flow:")}
+  ${pc.cyan(terminalFlow)}
+
+${pc.bold("Scanned Files:")} ${scanResult.totalFilesScanned}
 ${pc.bold("Total Components:")} ${totalComponents} across ${nonZeroLayers} active architectural layers
 ${pc.bold("Modules Detected:")} ${scanResult.modules.length > 0 ? scanResult.modules.join(", ") : "None (monolithic structure)"}
 ${pc.bold("Simulated Output:")} Would write ARCHITECTURE.md to ${pc.cyan(outputPath)} (dry run: no files written)`,
         pc.green("Architecture Map (Dry Run) \u{1F5FA}\uFE0F")
       );
+      if (options.tree) {
+        console.log(`
+${pc.bold("Directory Tree:")}
+${scanResult.directoryTree}
+`);
+      }
       p.outro(pc.cyan("Dry run completed: no files written."));
       return;
     }
@@ -1934,14 +2369,38 @@ ${pc.bold("Simulated Output:")} Would write ARCHITECTURE.md to ${pc.cyan(outputP
       fs3.mkdirSync(parentDir, { recursive: true });
     }
     fs3.writeFileSync(destination, markdown, "utf-8");
+    const shouldWriteHtml = options.html || options.view;
+    if (shouldWriteHtml) {
+      const htmlDestination = destination.replace(/\.md$/i, "") + ".html";
+      fs3.writeFileSync(htmlDestination, generateArchitectureHtml(scanResult), "utf-8");
+      p.log.success(`HTML architecture saved to ${pc.cyan(path4.relative(projectInfo.rootPath, htmlDestination) || htmlDestination)}`);
+      if (options.view) {
+        openViewer(htmlDestination);
+        p.log.info(pc.green("\u{1F310} Opened interactive architecture diagram in your browser!"));
+      }
+    }
+    if (options.tree) {
+      console.log(`
+${pc.bold("Directory Tree:")}
+${scanResult.directoryTree}
+`);
+    }
     p.note(
-      `${pc.bold("Scanned Files:")} ${scanResult.totalFilesScanned}
+      `${pc.bold("Architecture Flow:")}
+  ${pc.cyan(terminalFlow)}
+
+${pc.bold("Scanned Files:")} ${scanResult.totalFilesScanned}
 ${pc.bold("Total Components:")} ${totalComponents} across ${nonZeroLayers} active architectural layers
 ${pc.bold("Modules Detected:")} ${scanResult.modules.length > 0 ? scanResult.modules.join(", ") : "None (monolithic structure)"}
-${pc.bold("Documentation:")} Saved to ${pc.cyan(path4.relative(projectInfo.rootPath, destination) || outputPath)}`,
+${pc.bold("Documentation:")} Saved to ${pc.cyan(path4.relative(projectInfo.rootPath, destination) || outputPath)}
+
+${pc.bold("\u{1F4A1} How to view diagram:")}
+  \u2022 On GitHub: Push ${outputPath} (Mermaid renders automatically)
+  \u2022 In VS Code: Press ${pc.yellow("Ctrl+Shift+V")} for Markdown Preview
+  \u2022 In Browser: Run ${pc.cyan("npx larats view")} for instant local web preview`,
       pc.green("Architecture Map Generated! \u{1F5FA}\uFE0F")
     );
-    p.outro(pc.cyan(`Open ${outputPath} to view your project structure & Mermaid diagram!`));
+    p.outro(pc.cyan(`Done! Open ${outputPath} or run "npx larats view" to inspect architecture!`));
   } catch (err) {
     spinner2.stop(pc.red("Scan failed"));
     p.log.error(err.message || String(err));
@@ -2172,14 +2631,20 @@ async function main() {
         standard: { type: "boolean", short: "s" },
         force: { type: "boolean", short: "f" },
         "dry-run": { type: "boolean" },
+        view: { type: "boolean" },
+        tree: { type: "boolean", short: "t" },
+        html: { type: "boolean" },
         version: { type: "boolean", short: "v" },
+        copy: { type: "boolean" },
+        cursor: { type: "boolean" },
+        claude: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       },
       allowPositionals: true,
       strict: true
     });
   } catch (err) {
-    console.error(pc.red(`Error: ${err.message}`));
+    console.error(pc.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
     showHelp();
     process.exitCode = 1;
     return;
@@ -2193,8 +2658,17 @@ async function main() {
     return;
   }
   const command = parsed.positionals[0];
-  const VALID_COMMANDS = /* @__PURE__ */ new Set(["scan", "scaffold", "make", "info", "help"]);
-  if (command && !VALID_COMMANDS.has(command)) {
+  const VALID_COMMANDS = {
+    scan: true,
+    view: true,
+    preview: true,
+    scaffold: true,
+    make: true,
+    info: true,
+    ai: true,
+    help: true
+  };
+  if (command && !VALID_COMMANDS[command]) {
     console.error(pc.red(`Error: Unknown command "${command}".`));
     showHelp();
     process.exitCode = 1;
@@ -2205,14 +2679,52 @@ async function main() {
   const isStandardFlag = parsed.values.standard;
   const isForceFlag = parsed.values.force;
   const isDryRunFlag = parsed.values["dry-run"];
+  const isViewFlag = parsed.values.view;
+  const isTreeFlag = parsed.values.tree;
+  const isHtmlFlag = parsed.values.html;
   const projectInfo = await detectProjectType(process.cwd());
   if (command === "scan") {
     p.intro(`${pc.bgCyan(pc.black(" LaraTS "))} ${pc.gray(`v${VERSION}`)} - Scanning Architecture`);
     p.log.info(`Detected: ${pc.green(projectInfo.summary)}`);
     await runScan(projectInfo, outputPath, {
       force: isForceFlag,
-      dryRun: isDryRunFlag
+      dryRun: isDryRunFlag,
+      view: isViewFlag,
+      tree: isTreeFlag,
+      html: isHtmlFlag
+    });
+    await checkAndPromptStar();
+    return;
+  }
+  if (command === "view" || command === "preview") {
+    p.intro(`${pc.bgCyan(pc.black(" LaraTS "))} ${pc.gray(`v${VERSION}`)} - Architecture Viewer`);
+    p.log.info(`Target: ${pc.green(projectInfo.summary)}`);
+    const spinner2 = p.spinner();
+    spinner2.start("Scanning repository & generating architecture map...");
+    const scanResult = await scanProject(projectInfo);
+    spinner2.stop(pc.green(`Scanned ${scanResult.totalFilesScanned} files in ${scanResult.scanDurationMs}ms`));
+    const htmlDestination = path4.resolve(projectInfo.rootPath, "ARCHITECTURE.html");
+    fs3.writeFileSync(htmlDestination, generateArchitectureHtml(scanResult), "utf-8");
+    openViewer(htmlDestination);
+    p.note(
+      `${pc.bold("File:")} ${pc.cyan("ARCHITECTURE.html")}
+Interactive Mermaid.js flowchart & component breakdown loaded in your browser.
+Double-click ${pc.cyan("ARCHITECTURE.html")} anytime to view offline!`,
+      pc.green("Opened in Browser! \u{1F310}")
+    );
+    p.outro(pc.cyan("Done!"));
+    await checkAndPromptStar();
+    return;
+  }
+  if (command === "ai") {
+    p.intro(`${pc.bgCyan(pc.black(" LaraTS "))} ${pc.gray(`v${VERSION}`)} - AI Architecture Context`);
+    p.log.info(`Target: ${pc.green(projectInfo.summary)}`);
+    await runAi(projectInfo, {
+      copy: parsed.values.copy,
+      cursor: parsed.values.cursor,
+      claude: parsed.values.claude
     });
+    await checkAndPromptStar();
     return;
   }
   if (command === "scaffold" || command === "make") {
@@ -2225,12 +2737,14 @@ async function main() {
       force: isForceFlag,
       dryRun: isDryRunFlag
     });
+    await checkAndPromptStar();
     return;
   }
   if (command === "info") {
     p.intro(`${pc.bgCyan(pc.black(" LaraTS "))} ${pc.gray(`v${VERSION}`)}`);
     showProjectInfo(projectInfo);
     p.outro(pc.cyan("Done."));
+    await checkAndPromptStar();
     return;
   }
   if (!process.stdin.isTTY) {
@@ -2248,6 +2762,16 @@ async function main() {
         label: "\u{1F50D} Scan Architecture & Generate ARCHITECTURE.md",
         hint: "Creates component stats, directory tree & Mermaid flowchart"
       },
+      {
+        value: "ai",
+        label: "\u{1F916} Export Architecture Context for AI (Cursor, Claude, Copilot)",
+        hint: "Generate architecture rules for AI coding agents"
+      },
+      {
+        value: "view",
+        label: "\u{1F310} Open Interactive Architecture Viewer in Browser",
+        hint: "Spawns local browser tab with Mermaid flowchart & stats"
+      },
       {
         value: "scaffold",
         label: "\u{1F3D7}\uFE0F  Scaffold New Feature / Module",
@@ -2270,8 +2794,38 @@ async function main() {
   if (action === "scan") {
     await runScan(projectInfo, outputPath, {
       force: isForceFlag,
-      dryRun: isDryRunFlag
+      dryRun: isDryRunFlag,
+      view: isViewFlag,
+      tree: isTreeFlag,
+      html: isHtmlFlag
     });
+  } else if (action === "ai") {
+    const aiTarget = await p.select({
+      message: "How would you like to export the AI architecture context?",
+      options: [
+        { value: "copy", label: "\u{1F4CB} Copy directly to Clipboard", hint: "Ready to paste into ChatGPT or Claude web" },
+        { value: "cursor", label: "\u{1F5B1}\uFE0F  Save into .cursorrules", hint: "Inject rules for Cursor AI" },
+        { value: "claude", label: "\u{1F9E0} Save into CLAUDE.md", hint: "Inject rules for Claude Code" },
+        { value: "print", label: "\u{1F5A5}\uFE0F  Display prompt in terminal", hint: "View formatted markdown text" }
+      ]
+    });
+    if (p.isCancel(aiTarget)) {
+      handleCancel();
+    }
+    await runAi(projectInfo, {
+      copy: aiTarget === "copy",
+      cursor: aiTarget === "cursor",
+      claude: aiTarget === "claude"
+    });
+  } else if (action === "view") {
+    const spinner2 = p.spinner();
+    spinner2.start("Scanning repository & generating architecture map...");
+    const scanResult = await scanProject(projectInfo);
+    spinner2.stop(pc.green(`Scanned in ${scanResult.scanDurationMs}ms`));
+    const htmlDestination = path4.resolve(projectInfo.rootPath, "ARCHITECTURE.html");
+    fs3.writeFileSync(htmlDestination, generateArchitectureHtml(scanResult), "utf-8");
+    openViewer(htmlDestination);
+    p.outro(pc.green("\u{1F310} Opened interactive architecture diagram in your browser!"));
   } else if (action === "scaffold") {
     await runScaffold(projectInfo, void 0, {
       modular: isModularFlag,
@@ -2283,9 +2837,13 @@ async function main() {
     showProjectInfo(projectInfo);
     p.outro(pc.cyan("Done!"));
   }
+  await checkAndPromptStar();
 }
 main().catch((err) => {
   p.log.error(pc.red(`Fatal error: ${err.message || String(err)}`));
   process.exit(1);
 });
+export {
+  checkAndPromptStar
+};
 //# sourceMappingURL=index.js.map