@mettlecast/domain-cli 0.2.0

package/src/commands/add-module.ts

@@ -0,0 +1,347 @@
+import { execSync } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Readable } from 'node:stream';
+import { Parser as TarParser } from 'tar';
+import { readScaffoldConfig, writeScaffoldConfig } from '../utils/scaffold-config.js';
+import { readManifest, writeManifest, upsertManifestFile, inferPolicyFromPath } from '../utils/manifest.js';
+import { fetchModulesJson, fetchModuleTarball } from '../utils/s3-fetch.js';
+import { applyTokens, buildTokenContext, stripTplExtension } from '../utils/token-substitution.js';
+import { injectHeader } from '../utils/header-inject.js';
+import { computeChecksumString } from '../utils/checksum.js';
+import { installScaffoldFile } from '../utils/install-file.js';
+import { cliLogger } from '../utils/logger.js';
+
+export interface AddModuleOptions {
+  moduleId: string;
+  githubToken?: string;
+  dryRun?: boolean;
+  projectDir?: string;
+}
+
+interface TarballManifestEntry {
+  path: string;
+  installedAs?: string;
+  isTemplate: boolean;
+  policy?: 'owned' | 'tracked' | 'seed';
+}
+
+interface TarEntry {
+  path: string;
+  content: Buffer;
+}
+
+async function parseTarball(buf: Buffer): Promise<TarEntry[]> {
+  const entries: TarEntry[] = [];
+  const chunks: { [key: string]: Buffer[] } = {};
+
+  await new Promise<void>((resolve, reject) => {
+    const parser = new TarParser({
+      onentry: (entry) => {
+        const p = entry.path;
+        chunks[p] = [];
+        entry.on('data', (chunk: Buffer) => chunks[p].push(chunk));
+      },
+    });
+    parser.on('finish', resolve);
+    parser.on('error', reject);
+    Readable.from(buf).pipe(parser);
+  });
+
+  for (const [path, buffers] of Object.entries(chunks)) {
+    if (buffers.length > 0) {
+      entries.push({ path, content: Buffer.concat(buffers) });
+    }
+  }
+
+  return entries;
+}
+
+function getTarEntry(entries: TarEntry[], path: string): TarEntry | undefined {
+  return entries.find((e) => e.path === path);
+}
+
+async function getCliVersion(): Promise<string> {
+  try {
+    const { createRequire } = await import('node:module');
+    const require = createRequire(import.meta.url);
+    const pkgJson = require('../../package.json') as { version: string };
+    return pkgJson.version;
+  } catch {
+    return '0.0.0';
+  }
+}
+
+async function detectRepoInfo(): Promise<{ owner: string; repo: string } | null> {
+  try {
+    const remoteUrl = execSync('git remote get-url origin', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+
+    // Parse git@github.com:owner/repo.git or https://github.com/owner/repo.git
+    let match = /github\.com[:/]([^/]+)\/(.+?)(?:\.git)?$/.exec(remoteUrl);
+    if (match) {
+      return { owner: match[1], repo: match[2].replace(/\.git$/, '') };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function createGitHubPR(
+  owner: string,
+  repo: string,
+  branchName: string,
+  title: string,
+  body: string,
+  token: string
+): Promise<{ prUrl: string; prNumber: number } | null> {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        title,
+        body,
+        head: branchName,
+        base: 'develop',
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      cliLogger.warn(error, 'Failed to create GitHub PR');
+      return null;
+    }
+
+    const data = (await response.json()) as { html_url?: string; number?: number };
+    if (data.html_url && data.number) {
+      return { prUrl: data.html_url, prNumber: data.number };
+    }
+    return null;
+  } catch (err) {
+    cliLogger.warn(err, 'Failed to create GitHub PR');
+    return null;
+  }
+}
+
+export async function runAddModule(opts: AddModuleOptions): Promise<void> {
+  const projectDir = opts.projectDir ?? process.cwd();
+  const moduleId = opts.moduleId;
+  const dryRun = opts.dryRun ?? false;
+
+  // 1. Read .mc/scaffold-config.json
+  let config;
+  try {
+    config = await readScaffoldConfig(projectDir);
+  } catch (err) {
+    throw new Error(`Failed to read scaffold config from ${projectDir}: ${err}`);
+  }
+
+  // 2. Fetch modules.json from S3
+  let modulesJson;
+  try {
+    modulesJson = await fetchModulesJson(config.scaffoldBucket, config.scaffoldVersion);
+  } catch (err) {
+    throw new Error(`Failed to fetch modules.json for version ${config.scaffoldVersion}: ${err}`);
+  }
+
+  // 3. Validate moduleId is a known module
+  const module = modulesJson.modules.find((m) => m.id === moduleId);
+  if (!module) {
+    const available = modulesJson.modules.map((m) => m.id).join(', ');
+    throw new Error(`Unknown module "${moduleId}". Available modules: ${available}`);
+  }
+
+  // 4. Check moduleId is NOT already installed
+  if (config.enabledModules.includes(moduleId as any)) {
+    throw new Error(`Module "${moduleId}" is already installed`);
+  }
+
+  // 5. Check all dependencies of moduleId ARE installed
+  for (const dep of module.dependencies) {
+    if (!config.enabledModules.includes(dep as any)) {
+      throw new Error(
+        `Module "${moduleId}" requires "${dep}" which is not installed. ` +
+        `Install "${dep}" first with: tib add-module ${dep}`
+      );
+    }
+  }
+
+  // 6. Fetch tarball from S3
+  let tarBuf;
+  try {
+    tarBuf = await fetchModuleTarball(
+      config.scaffoldBucket,
+      config.scaffoldVersion,
+      module.tarball,
+      module.sha256
+    );
+  } catch (err) {
+    throw new Error(`Failed to fetch tarball for ${moduleId}: ${err}`);
+  }
+
+  // 7. Parse tarball
+  const tarEntries = await parseTarball(tarBuf);
+
+  // 8. Extract MANIFEST.json
+  const manifestEntry = getTarEntry(tarEntries, 'MANIFEST.json');
+  if (!manifestEntry) {
+    throw new Error(`No MANIFEST.json found in tarball for ${moduleId}`);
+  }
+
+  const tarManifest = JSON.parse(manifestEntry.content.toString('utf-8')) as TarballManifestEntry[];
+
+  // 9. Read manifest.json
+  let manifest = await readManifest(projectDir);
+  if (!manifest) {
+    throw new Error(`No .mc/manifest.json found in ${projectDir}`);
+  }
+
+  // 10. Get CLI version for header
+  const cliVersion = await getCliVersion();
+
+  // 11. Build token context
+  const tokenCtx = buildTokenContext(config, config.scaffoldVersion, cliVersion);
+
+  // 12. Process files from tarball
+  const filesInstalled: string[] = [];
+
+  for (const fileEntry of tarManifest) {
+    const tarEntry = getTarEntry(tarEntries, fileEntry.path);
+    if (!tarEntry) {
+      cliLogger.warn({ moduleId, path: fileEntry.path }, 'File in MANIFEST.json not found in tarball');
+      continue;
+    }
+
+    // Determine install path
+    let installPath = fileEntry.installedAs ?? fileEntry.path;
+
+    // Strip .tpl extension
+    if (installPath.endsWith('.tpl')) {
+      installPath = stripTplExtension(installPath);
+    }
+
+    // Process content
+    let content = tarEntry.content.toString('utf-8');
+
+    // Token substitution for template files
+    if (fileEntry.isTemplate) {
+      content = applyTokens(content, tokenCtx);
+    }
+
+    // Inject scaffold header
+    content = injectHeader(content, installPath, moduleId, module.version);
+
+    if (!dryRun) {
+      // Determine policy: use fileEntry.policy if present, else infer from path
+      const policy = fileEntry.policy ?? inferPolicyFromPath(installPath);
+
+      // Get current entry if exists
+      const currentEntry = manifest.files.find((f) => f.path === installPath);
+
+      // Install file using policy-based dispatch
+      const destPath = join(projectDir, installPath);
+      const installResult = await installScaffoldFile(destPath, content, policy, currentEntry, {
+        dryRun: false,
+      });
+
+      // Only update manifest if file was not skipped
+      if (installResult.status !== 'skipped') {
+        const sha256 = computeChecksumString(content);
+        upsertManifestFile(manifest, {
+          path: installPath,
+          module: moduleId,
+          moduleVersion: module.version,
+          sha256,
+          wasTemplate: fileEntry.isTemplate,
+          installedAt: new Date().toISOString(),
+          policy,
+        });
+      }
+    }
+
+    filesInstalled.push(installPath);
+  }
+
+  if (dryRun) {
+    console.log(`\n✓ Dry run: would install ${filesInstalled.length} file(s) from ${moduleId}@${module.version}`);
+    filesInstalled.forEach((f) => console.log(`  ${f}`));
+    console.log(
+      `\nTo apply changes, run: tib add-module ${moduleId}\n`
+    );
+    return;
+  }
+
+  // 13. Update .mc/manifest.json
+  await writeManifest(projectDir, manifest);
+
+  // 14. Update .mc/scaffold-config.json
+  config.enabledModules = [...config.enabledModules, moduleId as any];
+  await writeScaffoldConfig(projectDir, config);
+
+  console.log(
+    `\n✓ Module "${moduleId}" installed (${filesInstalled.length} file(s) added)`
+  );
+
+  // 15. Git operations
+  const branchName = `tib/add-module-${moduleId}`;
+  let commitSha: string | null = null;
+
+  try {
+    // Create new branch
+    execSync(`git -C "${projectDir}" checkout -b ${branchName}`, { stdio: 'pipe' });
+
+    // Stage changes
+    execSync(`git -C "${projectDir}" add .mc/`, { stdio: 'pipe' });
+
+    // Commit
+    const commitMsg = `feat: add tib module ${moduleId}@${config.scaffoldVersion}`;
+    execSync(`git -C "${projectDir}" commit -m "${commitMsg}"`, { stdio: 'pipe' });
+
+    commitSha = execSync(`git -C "${projectDir}" rev-parse HEAD`, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+
+    cliLogger.info({ moduleId, commitSha, branchName }, 'Module commit created');
+  } catch (err) {
+    cliLogger.warn(err, `Failed to create git commit for module ${moduleId}`);
+  }
+
+  // 16. GitHub PR creation if token available
+  const githubToken = opts.githubToken ?? process.env.GITHUB_TOKEN;
+
+  if (githubToken && commitSha) {
+    try {
+      // Push branch to remote
+      execSync(`git -C "${projectDir}" push -u origin ${branchName}`, { stdio: 'pipe' });
+
+      const repoInfo = await detectRepoInfo();
+      if (repoInfo) {
+        const prResult = await createGitHubPR(
+          repoInfo.owner,
+          repoInfo.repo,
+          branchName,
+          `feat: add tib module ${moduleId}`,
+          `Adds optional scaffold module: ${moduleId}@${config.scaffoldVersion}\n\nFiles added: ${filesInstalled.length}`,
+          githubToken
+        );
+
+        if (prResult) {
+          console.log(`\nPR created: ${prResult.prUrl}`);
+          cliLogger.info({ prUrl: prResult.prUrl, prNumber: prResult.prNumber }, 'Module PR created');
+        }
+      }
+    } catch (err) {
+      cliLogger.warn(err, 'Failed to push and create PR');
+    }
+  } else if (commitSha) {
+    console.log(`\nBranch "${branchName}" created. Push with: git push -u origin ${branchName}`);
+  }
+}

package/src/commands/add-page.ts

@@ -0,0 +1,242 @@
+import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import { join, resolve, dirname, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Readable } from 'node:stream';
+import { Parser as TarParser } from 'tar';
+import { cliLogger } from '../utils/logger.js';
+import { readScaffoldConfig } from '../utils/scaffold-config.js';
+import { fetchModulesJson, fetchModuleTarball } from '../utils/s3-fetch.js';
+import {
+  type PagePattern,
+  PAGE_PATTERNS,
+  listPageTemplate,
+  detailPageTemplate,
+  formPageTemplate,
+  wizardPageTemplate,
+  dashboardPageTemplate,
+  settingsPageTemplate,
+} from '../templates/patterns/page/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = resolve(__dirname, '..', 'templates', 'dashboard-pages');
+
+/** Map from pattern name to its template function. */
+const PATTERN_TEMPLATES: Record<PagePattern, (name: string) => string> = {
+  list: listPageTemplate,
+  detail: detailPageTemplate,
+  form: formPageTemplate,
+  wizard: wizardPageTemplate,
+  dashboard: dashboardPageTemplate,
+  settings: settingsPageTemplate,
+};
+
+const KEBAB_REGEX = /^[a-z][a-z0-9-]*$/;
+
+export interface AddPageOptions {
+  pageId: string;
+  outputDir?: string;
+  auth?: boolean;
+  protected?: boolean;
+  public?: boolean;
+  /** Pattern-based scaffolding (list, detail, form, wizard, dashboard, settings). */
+  pattern?: PagePattern;
+  /** Layout to use: app (default) or auth. */
+  layout?: 'app' | 'auth';
+}
+
+interface PageEntry {
+  id: string;
+  category: string;
+  path: string;
+  name: string;
+}
+
+async function loadRegistry(): Promise<PageEntry[]> {
+  // Dynamic import avoids tsx compilation issues with .tsx templates
+  const mod = await import('../templates/dashboard-pages/index.js') as { PAGE_REGISTRY: readonly PageEntry[] };
+  return [...mod.PAGE_REGISTRY];
+}
+
+function getCategoryForPageId(pageId: string): string {
+  const authPages = ['login', 'signup', 'verify-email', 'forgot-password', 'reset-password', 'mfa-setup', 'mfa-verify', 'choose-org', 'accept-invitation', 'sign-out'];
+  const accountPages = ['profile', 'workspace-settings', 'members', 'api-keys', 'audit-log'];
+
+  if (authPages.includes(pageId)) return 'auth';
+  if (accountPages.includes(pageId)) return 'account';
+  return 'shell';
+}
+
+async function fetchPageFromS3(
+  scaffoldBucket: string,
+  scaffoldVersion: string,
+  pageId: string
+): Promise<string | null> {
+  try {
+    const modulesJson = await fetchModulesJson(scaffoldBucket, scaffoldVersion);
+    const frontendModule = modulesJson.modules.find(m => m.id === 'frontend');
+
+    if (!frontendModule) {
+      throw new Error(`Frontend module not found in modules.json for version ${scaffoldVersion}`);
+    }
+
+    const tarballBuffer = await fetchModuleTarball(
+      scaffoldBucket,
+      scaffoldVersion,
+      frontendModule.tarball,
+      frontendModule.sha256
+    );
+
+    // Extract the page file from the tarball
+    const pageFileName = `${pageId}.tsx`;
+    const category = getCategoryForPageId(pageId);
+    const expectedPath = `frontend/src/pages/${category}/${pageFileName}`;
+
+    let content = '';
+    const chunks: Buffer[] = [];
+
+    await new Promise<void>((resolve, reject) => {
+      const parser = new TarParser({
+        onentry: (entry) => {
+          if (entry.path === expectedPath) {
+            entry.on('data', (chunk: Buffer) => chunks.push(chunk));
+          } else {
+            entry.resume();
+          }
+        },
+      });
+      parser.on('finish', resolve);
+      parser.on('error', reject);
+      Readable.from(tarballBuffer).pipe(parser);
+    });
+
+    if (chunks.length === 0) {
+      throw new Error(`Page template not found at ${expectedPath} in frontend tarball`);
+    }
+
+    content = Buffer.concat(chunks).toString('utf-8');
+    return content;
+  } catch (err) {
+    cliLogger.warn(err, 'Failed to fetch from S3, falling back to local templates');
+    return null;
+  }
+}
+
+async function loadFromLocal(pageId: string, entry: PageEntry): Promise<string> {
+  const templatePath = join(TEMPLATES_DIR, entry.path);
+  try {
+    const content = await readFile(templatePath, 'utf8');
+    cliLogger.warn({ pageId }, 'Using local fallback template (scaffold version not available)');
+    return content;
+  } catch {
+    throw new Error(`Template file not found at ${templatePath}`);
+  }
+}
+
+export async function runAddPage(opts: AddPageOptions): Promise<void> {
+  const { pageId, pattern, layout = 'app' } = opts;
+
+  if (!KEBAB_REGEX.test(pageId)) {
+    throw new Error(`Invalid page id "${pageId}" — must be kebab-case`);
+  }
+
+  // ── Pattern mode ──
+  if (pattern) {
+    if (!PAGE_PATTERNS.includes(pattern)) {
+      const available = PAGE_PATTERNS.join(', ');
+      throw new Error(
+        `Unknown page pattern "${pattern}".\n\nAvailable patterns: ${available}`
+      );
+    }
+
+    const templateFn = PATTERN_TEMPLATES[pattern];
+    let content = templateFn(pageId);
+
+    // Prepend layout comment
+    const layoutComment = `// Layout: ${layout === 'auth' ? 'AuthLayout' : 'AppLayout'} — import and use in your router config\n\n`;
+    content = layoutComment + content;
+
+    const outDir = opts.outputDir
+      ? resolve(opts.outputDir)
+      : resolve(process.cwd(), 'src', 'pages', pageId);
+
+    await mkdir(outDir, { recursive: true });
+
+    const fileName = `${pageId}.tsx`;
+    const outPath = join(outDir, fileName);
+
+    // Refuse if target already exists
+    try {
+      await access(outPath);
+      throw new Error(`File already exists at ${outPath}. Remove it first or use a different --output directory.`);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+    }
+
+    await writeFile(outPath, content, 'utf8');
+
+    cliLogger.info({ pageId, pattern, layout, outPath }, 'Page scaffolded from pattern');
+    // eslint-disable-next-line no-console
+    console.log(
+      `\n✓ Page "${pageId}" (pattern: ${pattern}, layout: ${layout}) added at ${outPath}\n` +
+      `  Next: add a route in src/router.tsx for this page\n`
+    );
+    return;
+  }
+
+  // ── Registry mode (existing behaviour) ──
+  const registry = await loadRegistry();
+  const entry = registry.find(p => p.id === pageId);
+
+  if (!entry) {
+    const available = registry.map(p => p.id).join(', ');
+    throw new Error(
+      `Unknown page id "${pageId}".\n\nAvailable pages: ${available}\n` +
+      `Tip: use --pattern <pattern> to scaffold with a page pattern. Available patterns: ${PAGE_PATTERNS.join(', ')}`
+    );
+  }
+
+  let content: string | null = null;
+
+  // Try S3 fetch first
+  try {
+    const config = await readScaffoldConfig(process.cwd());
+    if (config.scaffoldVersion && config.scaffoldBucket) {
+      content = await fetchPageFromS3(config.scaffoldBucket, config.scaffoldVersion, pageId);
+    }
+  } catch (err) {
+    cliLogger.debug(err, 'Could not read scaffold config');
+  }
+
+  // Fall back to local templates
+  if (!content) {
+    content = await loadFromLocal(pageId, entry);
+  }
+
+  const outDir = opts.outputDir
+    ? resolve(opts.outputDir)
+    : resolve(process.cwd(), 'src', 'pages', entry.category);
+
+  await mkdir(outDir, { recursive: true });
+
+  const fileName = `${basename(entry.path)}`;
+  const outPath = join(outDir, fileName);
+
+  // Refuse if target already exists
+  try {
+    await access(outPath);
+    throw new Error(`File already exists at ${outPath}. Remove it first or use a different --output directory.`);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+  }
+
+  await writeFile(outPath, content, 'utf8');
+
+  cliLogger.info({ pageId, layout, outPath }, 'Page scaffolded');
+  // eslint-disable-next-line no-console
+  console.log(
+    `\n✓ Page "${pageId}" (layout: ${layout}) added at ${outPath}\n` +
+    `  Component: ${entry.name}\n` +
+    `  Next: import { ${entry.name} } from './${entry.category}/${basename(entry.path, '.tsx')}'\n` +
+    `  Then add a route in src/router.tsx\n`
+  );
+}