@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/lib/dotnet.ts

@@ -0,0 +1,238 @@
+/**
+ * lib/dotnet.ts — .NET / EF Core helpers for dev CLIs.
+ * Ported from SmartStack.cli/src/mcp/utils/dotnet.ts.
+ *
+ * Used by detector.ts and any CLI that needs to reason about .csproj files,
+ * target frameworks, EF Core migrations, or package references.
+ */
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { findFiles, readText } from './fs.js';
+
+const execAsync = promisify(exec);
+
+export async function dotnet(command: string, cwd?: string): Promise<string> {
+  const options = cwd ? { cwd } : {};
+  const { stdout } = await execAsync(`dotnet ${command}`, options);
+  return stdout.trim();
+}
+
+export async function isDotnetAvailable(): Promise<boolean> {
+  try {
+    await execAsync('dotnet --version');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getDotnetVersion(): Promise<string | null> {
+  try {
+    return await dotnet('--version');
+  } catch {
+    return null;
+  }
+}
+
+export async function findCsprojFiles(cwd?: string): Promise<string[]> {
+  return findFiles('**/*.csproj', { cwd: cwd || process.cwd() });
+}
+
+export async function hasEfCore(csprojPath: string): Promise<boolean> {
+  try {
+    const content = await readText(csprojPath);
+    return content.includes('Microsoft.EntityFrameworkCore');
+  } catch {
+    return false;
+  }
+}
+
+export async function findDbContextName(projectPath: string): Promise<string | null> {
+  try {
+    const csFiles = await findFiles('**/*.cs', { cwd: projectPath });
+    for (const file of csFiles) {
+      const content = await readText(file);
+      const match = content.match(/class\s+(\w+)\s*:\s*(?:\w+,\s*)*DbContext/);
+      if (match) return match[1];
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function listMigrations(
+  projectPath: string,
+  context?: string,
+): Promise<string[]> {
+  try {
+    const contextArg = context ? `--context ${context}` : '';
+    const result = await dotnet(`ef migrations list ${contextArg}`, projectPath);
+    return result
+      .split('\n')
+      .filter((line) => line && !line.startsWith('Build') && !line.includes('...'))
+      .map((line) => line.trim());
+  } catch {
+    return [];
+  }
+}
+
+export async function getPendingMigrations(
+  projectPath: string,
+  context?: string,
+): Promise<string[]> {
+  try {
+    const contextArg = context ? `--context ${context}` : '';
+    const result = await dotnet(`ef migrations list ${contextArg} --pending`, projectPath);
+    return result
+      .split('\n')
+      .filter((line) => line && !line.startsWith('Build') && !line.includes('...'))
+      .map((line) => line.trim());
+  } catch {
+    return [];
+  }
+}
+
+export async function buildProject(
+  projectPath: string,
+): Promise<{ success: boolean; output: string }> {
+  try {
+    const output = await dotnet('build --no-restore', projectPath);
+    return { success: true, output };
+  } catch (error) {
+    const err = error as { stdout?: string; stderr?: string };
+    return {
+      success: false,
+      output: err.stdout || err.stderr || 'Build failed',
+    };
+  }
+}
+
+export async function getPackageReferences(
+  csprojPath: string,
+): Promise<Array<{ name: string; version: string }>> {
+  try {
+    const content = await readText(csprojPath);
+    const packages: Array<{ name: string; version: string }> = [];
+    const regex = /<PackageReference\s+Include="([^"]+)"\s+Version="([^"]+)"/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      packages.push({ name: match[1], version: match[2] });
+    }
+    return packages;
+  } catch {
+    return [];
+  }
+}
+
+export async function getTargetFramework(csprojPath: string): Promise<string | null> {
+  try {
+    const content = await readText(csprojPath);
+    const match = content.match(/<TargetFramework>([^<]+)<\/TargetFramework>/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+export function getProjectName(csprojPath: string): string {
+  return path.basename(csprojPath, '.csproj');
+}
+
+export interface NamespaceConfig {
+  baseNamespace: string;
+  domain: string;
+  application: string;
+  infrastructure: string;
+  api: string;
+}
+
+/**
+ * Detect the base namespace + per-layer namespaces from a list of .csproj files.
+ * Recognizes the common layer suffixes (Domain, Application, Infrastructure, Api).
+ *   ["MyProject.Domain.csproj", "MyProject.Api.csproj"] → { baseNamespace: "MyProject", ... }
+ *   ["Acme.Corp.Domain.csproj", "Acme.Corp.Api.csproj"] → { baseNamespace: "Acme.Corp", ... }
+ */
+export async function detectNamespaces(csprojFiles: string[]): Promise<NamespaceConfig | null> {
+  if (csprojFiles.length === 0) return null;
+
+  const projectNames = csprojFiles.map((f) => path.basename(f, '.csproj'));
+  const layerSuffixes = [
+    'Domain',
+    'Application',
+    'Infrastructure',
+    'Api',
+    'Web',
+    'Core',
+    'Tests',
+  ];
+
+  const baseNamespaces: string[] = [];
+
+  for (const name of projectNames) {
+    const parts = name.split('.');
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const part = parts[i];
+      if (layerSuffixes.some((s) => s.toLowerCase() === part.toLowerCase())) {
+        const baseParts = parts.slice(0, i);
+        if (baseParts.length > 0) baseNamespaces.push(baseParts.join('.'));
+        break;
+      }
+    }
+  }
+
+  if (baseNamespaces.length === 0) {
+    const commonPrefix = findCommonPrefix(projectNames);
+    if (commonPrefix && commonPrefix.length > 0) {
+      const base = commonPrefix.replace(/\.$/, '');
+      if (base) baseNamespaces.push(base);
+    }
+  }
+
+  if (baseNamespaces.length === 0) return null;
+
+  const baseNamespace = getMostCommon(baseNamespaces) || baseNamespaces[0];
+  return {
+    baseNamespace,
+    domain: `${baseNamespace}.Domain`,
+    application: `${baseNamespace}.Application`,
+    infrastructure: `${baseNamespace}.Infrastructure`,
+    api: `${baseNamespace}.Api`,
+  };
+}
+
+function findCommonPrefix(strings: string[]): string {
+  if (strings.length === 0) return '';
+  if (strings.length === 1) {
+    const parts = strings[0].split('.');
+    if (parts.length > 1) return parts.slice(0, -1).join('.') + '.';
+    return strings[0] + '.';
+  }
+  let prefix = strings[0];
+  for (let i = 1; i < strings.length; i++) {
+    while (strings[i].indexOf(prefix) !== 0 && prefix.length > 0) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  const lastDot = prefix.lastIndexOf('.');
+  if (lastDot > 0 && !prefix.endsWith('.')) {
+    prefix = prefix.slice(0, lastDot + 1);
+  }
+  return prefix;
+}
+
+function getMostCommon(arr: string[]): string | null {
+  if (arr.length === 0) return null;
+  const counts = new Map<string, number>();
+  for (const item of arr) counts.set(item, (counts.get(item) || 0) + 1);
+  let maxCount = 0;
+  let mostCommon = arr[0];
+  for (const [item, count] of counts) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommon = item;
+    }
+  }
+  return mostCommon;
+}

package/templates/skills/lib/frontend-fixers.ts

@@ -0,0 +1,151 @@
+/**
+ * lib/frontend-fixers.ts — Shared mechanical rewrite helpers for *.tsx pages.
+ *
+ * Used by both `ui-polish/apply.ts` (CSS / token rewrites) and
+ * `audit-dev-frontend/apply.ts` (PRD-vs-code rewrites). Keeping the shared
+ * fixers here avoids divergence between the two skills' implementations.
+ *
+ * Each fixer is a pure function: `(source, optsByRule) → string | null`.
+ * Returning null = "couldn't apply safely; mark as skipped".
+ */
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+/**
+ * Walk forward from after the opening JSX tag and find the matching `);` of
+ * the surrounding return(...). Returns the absolute offset of the `;` (or
+ * the closing `)` if no `;`). Returns -1 if no balanced close found.
+ */
+export function findMatchingReturnClose(text: string): number {
+  let depth = 1; // we already consumed the opening tag
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === '<') {
+      if (text[i + 1] === '/') depth--;
+      else if (text[i + 1] !== '!') depth++;
+    }
+    if (depth === 0) {
+      const close = text.slice(i).match(/>\s*\)\s*;?/);
+      if (!close) return -1;
+      return i + close.index! + close[0].length;
+    }
+    i++;
+  }
+  return -1;
+}
+
+/** Inject an import line after the last existing top-level import. */
+export function injectImport(source: string, importLine: string): string {
+  if (source.includes(importLine)) return source;
+  const lastImport = source.match(/^import[\s\S]*?from\s+['"][^'"]+['"];?\s*$/gm);
+  if (lastImport && lastImport.length > 0) {
+    const last = lastImport[lastImport.length - 1];
+    const insertAt = source.indexOf(last) + last.length;
+    return source.slice(0, insertAt) + `\n${importLine}` + source.slice(insertAt);
+  }
+  return importLine + '\n' + source;
+}
+
+// ─── Fixers ───────────────────────────────────────────────────────────────
+
+/**
+ * Wrap the page body in <PageTemplate title={...}>...</PageTemplate>.
+ *
+ * - Skips if PageTemplate is already imported and used.
+ * - Inserts the import after the last existing import.
+ * - Heuristic JSX wrap: replace `return ( <root>` with
+ *   `return ( <PageTemplate title={'TODO-title'}> <root>` and rebalance close.
+ * - Returns null if no JSX return found (page shape too exotic to patch).
+ *
+ * Equivalent to ui-polish's fixR1; extracted so audit-dev-frontend reuses it
+ * for DEV-UI-005.
+ */
+export function fixPageTemplateWrap(source: string): string | null {
+  if (!/from\s+['"]@\/components\/ui\/PageTemplate['"]/.test(source)) {
+    source = injectImport(source, `import { PageTemplate } from '@/components/ui/PageTemplate';`);
+  }
+  if (/<PageTemplate[\s>]/.test(source)) {
+    // Already wraps, just return source as-is (import was inserted if missing).
+    return source;
+  }
+  const returnMatch = source.match(/return\s*\(\s*\n(\s*)(<(?!PageTemplate\b|>|\/)[^>]+>)/);
+  if (!returnMatch) return null;
+  const indent = returnMatch[1];
+  const bodyOpen = returnMatch[2];
+  const beforeReturn = source.slice(0, returnMatch.index! + returnMatch[0].length - bodyOpen.length);
+  const afterBodyOpen = source.slice(returnMatch.index! + returnMatch[0].length);
+  const closingParenIdx = findMatchingReturnClose(afterBodyOpen);
+  if (closingParenIdx === -1) return null;
+  const bodyInner = afterBodyOpen.slice(0, closingParenIdx);
+  const rest = afterBodyOpen.slice(closingParenIdx);
+  return (
+    beforeReturn
+    + `<PageTemplate title={/* TODO: derive from useTranslation */ 'TODO-title'}>\n${indent}  ${bodyOpen}`
+    + bodyInner.replace(/\n/g, '\n  ')
+    + `\n${indent}</PageTemplate>`
+    + rest
+  );
+}
+
+/**
+ * Wrap the page body in <PermissionGuard permission="<key>">...</PermissionGuard>.
+ *
+ * Same shape as fixPageTemplateWrap but for PermissionGuard. If the page
+ * already wraps in <PageTemplate>, the guard goes outside (Permission first,
+ * then PageTemplate). Used for DEV-UI-011.
+ */
+export function fixPermissionGuardWrap(source: string, permission: string): string | null {
+  if (new RegExp(`PermissionGuard[^>]*permission=\\{?["'\`]${permission.replace(/\./g, '\\.')}["'\`]`).test(source)) {
+    return source; // already wrapped with this exact permission
+  }
+  if (!/from\s+['"]@\/components\/PermissionGuard['"]/.test(source) && !/PermissionGuard.*from\s+['"]@atlashub\/smartstack['"]/.test(source)) {
+    source = injectImport(source, `import { PermissionGuard } from '@/components/PermissionGuard';`);
+  }
+  const returnMatch = source.match(/return\s*\(\s*\n(\s*)(<(?!PermissionGuard\b|>|\/)[^>]+>)/);
+  if (!returnMatch) return null;
+  const indent = returnMatch[1];
+  const bodyOpen = returnMatch[2];
+  const beforeReturn = source.slice(0, returnMatch.index! + returnMatch[0].length - bodyOpen.length);
+  const afterBodyOpen = source.slice(returnMatch.index! + returnMatch[0].length);
+  const closingParenIdx = findMatchingReturnClose(afterBodyOpen);
+  if (closingParenIdx === -1) return null;
+  const bodyInner = afterBodyOpen.slice(0, closingParenIdx);
+  const rest = afterBodyOpen.slice(closingParenIdx);
+  return (
+    beforeReturn
+    + `<PermissionGuard permission="${permission}">\n${indent}  ${bodyOpen}`
+    + bodyInner.replace(/\n/g, '\n  ')
+    + `\n${indent}</PermissionGuard>`
+    + rest
+  );
+}
+
+/**
+ * Append a `PageRegistry.register(key, lazyWithRetry(() => import(importPath)))`
+ * line to the registry file source, AFTER the last existing register call (or
+ * at the end of the file if none exist).
+ *
+ * Used for DEV-UI-002 in-place fix when an orphan page exists and the
+ * appropriate module registry is identified. Uses `lazyWithRetry` (not bare
+ * `React.lazy`) for parity with scaffold-routes output — survives transient
+ * HMR/CDN chunk-load failures.
+ */
+export function appendRegistryEntry(source: string, key: string, importPath: string): string {
+  const registerLine = `PageRegistry.register('${key}', lazyWithRetry(() => import('${importPath}')));`;
+  if (source.includes(registerLine)) return source;
+  const lastRegister = [...source.matchAll(/(?:Page|Component)Registry\.register\s*\([^;]+;\s*$/gm)];
+  if (lastRegister.length > 0) {
+    const last = lastRegister[lastRegister.length - 1];
+    const insertAt = last.index! + last[0].length;
+    return source.slice(0, insertAt) + `\n${registerLine}` + source.slice(insertAt);
+  }
+  // No existing register call — append before the last closing brace if any.
+  if (!/import\s*\{[^}]*\b(?:lazy|lazyWithRetry)\b[^}]*\}\s*from/.test(source)) {
+    source = injectImport(source, `import { lazyWithRetry } from '@atlashub/smartstack';`);
+  }
+  if (!/import\s*\{[^}]*\bPageRegistry\b[^}]*\}\s*from/.test(source)) {
+    source = injectImport(source, `import { PageRegistry } from '@atlashub/smartstack';`);
+  }
+  return source.trimEnd() + '\n\n' + registerLine + '\n';
+}

package/templates/skills/lib/fs.ts

@@ -0,0 +1,238 @@
+/**
+ * lib/fs.ts — File system helpers for all SmartStack Studio dev CLIs.
+ * Ported from SmartStack.cli/src/mcp/utils/fs.ts (legacy V1).
+ *
+ * All functions are async and throw typed FileSystemError on failure.
+ * findFiles / findDirectories use glob with sensible defaults (node_modules/bin/obj excluded).
+ */
+import { stat, mkdir, readFile, writeFile, cp, rm, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { minimatch } from 'minimatch';
+
+export class FileSystemError extends Error {
+  constructor(
+    message: string,
+    public readonly operation: string,
+    public readonly path: string,
+    public readonly cause?: Error,
+  ) {
+    super(message);
+    this.name = 'FileSystemError';
+  }
+}
+
+/** Throw if targetPath escapes baseDir (path traversal protection). */
+export function validatePathSecurity(targetPath: string, baseDir: string): void {
+  const normalizedTarget = path.resolve(targetPath);
+  const normalizedBase = path.resolve(baseDir);
+  if (
+    !normalizedTarget.startsWith(normalizedBase + path.sep) &&
+    normalizedTarget !== normalizedBase
+  ) {
+    throw new FileSystemError(
+      `Path traversal detected: "${targetPath}" is outside allowed directory "${baseDir}"`,
+      'validatePathSecurity',
+      targetPath,
+    );
+  }
+}
+
+export function safeJoinPath(baseDir: string, ...segments: string[]): string {
+  const joined = path.join(baseDir, ...segments);
+  validatePathSecurity(joined, baseDir);
+  return joined;
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    const s = await stat(filePath);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+
+export async function directoryExists(dirPath: string): Promise<boolean> {
+  try {
+    const s = await stat(dirPath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDirectory(dirPath: string): Promise<void> {
+  await mkdir(dirPath, { recursive: true });
+}
+
+export async function readJson<T>(filePath: string): Promise<T> {
+  try {
+    const content = await readFile(filePath, 'utf-8');
+    try {
+      return JSON.parse(content) as T;
+    } catch (parseError) {
+      throw new FileSystemError(
+        `Invalid JSON in file: ${filePath}`,
+        'readJson',
+        filePath,
+        parseError instanceof Error ? parseError : undefined,
+      );
+    }
+  } catch (error) {
+    if (error instanceof FileSystemError) throw error;
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FileSystemError(
+      `Failed to read JSON file: ${filePath} - ${err.message}`,
+      'readJson',
+      filePath,
+      err,
+    );
+  }
+}
+
+export async function writeJson<T>(filePath: string, data: T): Promise<void> {
+  try {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FileSystemError(
+      `Failed to write JSON file: ${filePath} - ${err.message}`,
+      'writeJson',
+      filePath,
+      err,
+    );
+  }
+}
+
+export async function readText(filePath: string): Promise<string> {
+  try {
+    return await readFile(filePath, 'utf-8');
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FileSystemError(
+      `Failed to read file: ${filePath} - ${err.message}`,
+      'readText',
+      filePath,
+      err,
+    );
+  }
+}
+
+export async function writeText(filePath: string, content: string): Promise<void> {
+  try {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FileSystemError(
+      `Failed to write file: ${filePath} - ${err.message}`,
+      'writeText',
+      filePath,
+      err,
+    );
+  }
+}
+
+export async function copyFile(src: string, dest: string): Promise<void> {
+  await mkdir(path.dirname(dest), { recursive: true });
+  await cp(src, dest, { recursive: true });
+}
+
+export async function removeFile(filePath: string): Promise<void> {
+  await rm(filePath, { force: true });
+}
+
+export async function removeDirectory(dirPath: string): Promise<void> {
+  await rm(dirPath, { recursive: true, force: true });
+}
+
+const DEFAULT_IGNORE = [
+  '**/node_modules/**',
+  '**/bin/**',
+  '**/obj/**',
+  '**/dist/**',
+  '**/out/**',
+  '**/.git/**',
+];
+
+/**
+ * Recursively walk a directory and yield every entry (files AND subdirs) as
+ * absolute paths. Skips any entry whose relative-to-cwd path matches the
+ * ignorePatterns (minimatch).
+ */
+async function walk(
+  cwd: string,
+  options: { includeDirs: boolean; ignorePatterns: string[] },
+): Promise<string[]> {
+  const results: string[] = [];
+  const { includeDirs, ignorePatterns } = options;
+
+  async function visit(dir: string): Promise<void> {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return; // unreadable dir — skip
+    }
+    for (const entry of entries) {
+      const absolutePath = path.join(dir, entry.name);
+      const relative = path.relative(cwd, absolutePath).replace(/\\/g, '/');
+
+      const ignored = ignorePatterns.some((p) =>
+        minimatch(relative, p, { dot: true }),
+      );
+      if (ignored) continue;
+
+      if (entry.isDirectory()) {
+        if (includeDirs) results.push(absolutePath);
+        await visit(absolutePath);
+      } else if (entry.isFile()) {
+        if (!includeDirs) results.push(absolutePath);
+      }
+    }
+  }
+
+  await visit(cwd);
+  return results;
+}
+
+export async function findFiles(
+  pattern: string,
+  options: { cwd?: string; ignore?: string[] } = {},
+): Promise<string[]> {
+  const { cwd = process.cwd(), ignore = [] } = options;
+  const ignorePatterns = [...DEFAULT_IGNORE, ...ignore];
+
+  const all = await walk(cwd, { includeDirs: false, ignorePatterns });
+
+  // Match absolute paths against the pattern using the relative form
+  // (so patterns like "**/*.csproj" work as expected).
+  return all.filter((absolute) => {
+    const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
+    return minimatch(relative, pattern, { dot: true });
+  });
+}
+
+export async function findDirectories(
+  pattern: string,
+  options: { cwd?: string; ignore?: string[] } = {},
+): Promise<string[]> {
+  const { cwd = process.cwd(), ignore = [] } = options;
+  const ignorePatterns = [...DEFAULT_IGNORE, ...ignore];
+
+  const all = await walk(cwd, { includeDirs: true, ignorePatterns });
+
+  return all.filter((absolute) => {
+    const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
+    return minimatch(relative, pattern, { dot: true });
+  });
+}
+
+export function relativePath(from: string, to: string): string {
+  return path.relative(from, to).replace(/\\/g, '/');
+}
+
+export function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, '/');
+}