rapidkit 0.41.0 → 0.41.1

package/scripts/enterprise-package-smoke.mjs

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+const repoRoot = process.cwd();
+const cliPath = path.join(repoRoot, 'dist', 'index.js');
+
+function fail(message) {
+  console.error(`[enterprise-package-smoke] ${message}`);
+  process.exit(1);
+}
+
+function log(message) {
+  console.log(`[enterprise-package-smoke] ${message}`);
+}
+
+function cliEnv(extraEnv = {}) {
+  const env = { ...process.env, ...extraEnv };
+  delete env.NODE_ENV;
+  delete env.NODE_OPTIONS;
+  for (const key of Object.keys(env)) {
+    if (key.startsWith('VITEST')) {
+      delete env[key];
+    }
+  }
+  return env;
+}
+
+function commandExists(command, args = ['--version']) {
+  const result = spawnSync(command, args, { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+function resolveNpmInvocation() {
+  const npmExecPath = process.env.npm_execpath;
+  if (npmExecPath && fs.existsSync(npmExecPath)) {
+    return { command: process.execPath, prefixArgs: [npmExecPath] };
+  }
+
+  if (commandExists('corepack')) {
+    return { command: 'corepack', prefixArgs: ['npm'] };
+  }
+
+  if (commandExists('npm')) {
+    return { command: 'npm', prefixArgs: [] };
+  }
+
+  fail('could not resolve npm. Install npm or enable corepack before packaging.');
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...options,
+    env: cliEnv(options.env),
+  });
+  if (result.status !== 0) {
+    fail(
+      `command failed (${result.status}): ${command} ${args.join(' ')}\n${result.stdout ?? ''}\n${result.stderr ?? ''}`
+    );
+  }
+  return result.stdout ?? '';
+}
+
+function runToFile(command, args, options = {}) {
+  const outputPath = path.join(
+    os.tmpdir(),
+    `rapidkit-enterprise-command-${process.pid}-${Date.now()}-${Math.random()
+      .toString(16)
+      .slice(2)}.out`
+  );
+  const fd = fs.openSync(outputPath, 'w');
+  try {
+    const result = spawnSync(command, args, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', fd, 'pipe'],
+      ...options,
+      env: cliEnv(options.env),
+    });
+    if (result.status !== 0) {
+      fail(
+        `command failed (${result.status}): ${command} ${args.join(' ')}\n${result.stderr ?? ''}`
+      );
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  try {
+    return fs.readFileSync(outputPath, 'utf8');
+  } finally {
+    fs.rmSync(outputPath, { force: true });
+  }
+}
+
+function runNpm(args) {
+  const npm = resolveNpmInvocation();
+  return runToFile(npm.command, [...npm.prefixArgs, ...args], {
+    env: {
+      ...cliEnv(),
+      npm_config_user_agent: process.env.npm_config_user_agent || 'npm/10 rapidkit-smoke',
+      npm_config_cache:
+        process.env.npm_config_cache ||
+        path.join(os.tmpdir(), `rapidkit-enterprise-npm-cache-${process.pid}`),
+    },
+  });
+}
+
+function runCli(args) {
+  const outputPath = path.join(
+    os.tmpdir(),
+    `rapidkit-enterprise-cli-${process.pid}-${Date.now()}-${Math.random()
+      .toString(16)
+      .slice(2)}.out`
+  );
+  const fd = fs.openSync(outputPath, 'w');
+  try {
+    const result = spawnSync(process.execPath, [cliPath, ...args], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      env: cliEnv(),
+      stdio: ['ignore', fd, 'pipe'],
+    });
+    if (result.status !== 0) {
+      fail(
+        `CLI command failed (${result.status}): node dist/index.js ${args.join(' ')}\n${
+          result.stderr ?? ''
+        }`
+      );
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  try {
+    return fs.readFileSync(outputPath, 'utf8');
+  } finally {
+    fs.rmSync(outputPath, { force: true });
+  }
+}
+
+function assertFile(relativePath) {
+  const absolutePath = path.join(repoRoot, relativePath);
+  if (!fs.existsSync(absolutePath)) {
+    fail(`missing required file: ${relativePath}`);
+  }
+}
+
+function parseTrailingJson(stdout) {
+  const trimmed = stdout.trim();
+  const start = trimmed.lastIndexOf('\n{');
+  const jsonText = start >= 0 ? trimmed.slice(start + 1) : trimmed;
+  try {
+    return JSON.parse(jsonText);
+  } catch (error) {
+    fail(`failed to parse CLI JSON output: ${error instanceof Error ? error.message : error}`);
+  }
+}
+
+function assertPackContents() {
+  if (process.env.RAPIDKIT_ENTERPRISE_PREPACK === '1') {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+    const files = packageJson.files ?? [];
+    const isPublished = (assetPath) =>
+      files.some(
+        (entry) => entry === assetPath || assetPath.startsWith(`${entry.replace(/\/$/, '')}/`)
+      );
+
+    for (const required of [
+      'dist/index.js',
+      'contracts/runtime-command-surface.v1.json',
+      'contracts/extension-cli-compatibility.v1.json',
+      'data/modules-embeddings.json',
+      'templates/kits/fastapi-standard/README.md.j2',
+      'templates/kits/fastapi-ddd/README.md.j2',
+      'templates/kits/nestjs-standard/package.json.j2',
+      'scripts/check-cli-resolution.cjs',
+      'scripts/enforce-package-manager.cjs',
+    ]) {
+      if (!isPublished(required)) {
+        fail(`package.json#files does not publish ${required}`);
+      }
+    }
+
+    log('verified package.json#files payload policy for prepack lifecycle');
+    return;
+  }
+
+  const output = runNpm(['pack', '--dry-run', '--json', '--ignore-scripts']);
+  let packuments;
+  try {
+    packuments = JSON.parse(output);
+  } catch (error) {
+    fail(`npm pack --dry-run did not return JSON: ${error instanceof Error ? error.message : error}`);
+  }
+
+  const files = new Set(
+    (packuments?.[0]?.files ?? [])
+      .map((entry) => entry?.path)
+      .filter((entry) => typeof entry === 'string')
+  );
+
+  for (const required of [
+    'dist/index.js',
+    'contracts/runtime-command-surface.v1.json',
+    'contracts/extension-cli-compatibility.v1.json',
+    'data/modules-embeddings.json',
+    'templates/kits/fastapi-standard/README.md.j2',
+    'templates/kits/fastapi-ddd/README.md.j2',
+    'templates/kits/nestjs-standard/package.json.j2',
+    'scripts/check-cli-resolution.cjs',
+    'scripts/enforce-package-manager.cjs',
+  ]) {
+    if (!files.has(required)) {
+      fail(`npm pack payload is missing ${required}`);
+    }
+  }
+
+  for (const forbiddenPrefix of [
+    'node_modules/',
+    '.rapidkit/',
+    '.venv/',
+    'coverage/',
+    'test-results/',
+    'src/',
+  ]) {
+    const leaked = [...files].find((entry) => entry.startsWith(forbiddenPrefix));
+    if (leaked) {
+      fail(`npm pack payload leaks dev/local artifact: ${leaked}`);
+    }
+  }
+
+  log(`verified npm pack payload (${files.size} files)`);
+}
+
+function assertCliContracts() {
+  const version = parseTrailingJson(runCli(['--version', '--json']));
+  if (version.schemaVersion !== 'rapidkit-version-v1') {
+    fail(`unexpected version schema: ${version.schemaVersion}`);
+  }
+  if (!version.contracts?.runtimeCommandSurface) {
+    fail('version contract does not advertise runtimeCommandSurface');
+  }
+
+  const commands = parseTrailingJson(runCli(['commands', '--json']));
+  if (commands.schemaVersion !== 'rapidkit-command-capabilities-v1') {
+    fail(`unexpected commands schema: ${commands.schemaVersion}`);
+  }
+  for (const topLevel of ['create', 'workspace', 'doctor', 'bootstrap']) {
+    if (!commands.commandMap?.[topLevel]) {
+      fail(`commands surface is missing top-level command: ${topLevel}`);
+    }
+  }
+  for (const subcommand of ['model', 'snapshot', 'diff', 'impact', 'verify', 'context', 'explain']) {
+    if (!commands.workspace?.intelligenceSubcommands?.includes(subcommand)) {
+      fail(`workspace intelligence surface is missing subcommand: ${subcommand}`);
+    }
+  }
+
+  log(`verified CLI contract surfaces for v${version.version}`);
+}
+
+function assertGeneratedProject(projectPath, expectedFiles) {
+  for (const relativePath of expectedFiles) {
+    const absolutePath = path.join(projectPath, relativePath);
+    if (!fs.existsSync(absolutePath)) {
+      fail(`generated project ${path.basename(projectPath)} is missing ${relativePath}`);
+    }
+  }
+}
+
+function smokeCreateNpmBackedKits() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rapidkit-enterprise-smoke-'));
+  const scenarios = [
+    {
+      kit: 'gofiber.standard',
+      name: 'enterprise-fiber',
+      extraArgs: [],
+      expectedFiles: ['go.mod', 'cmd/server/main.go', '.rapidkit/project.json', 'rapidkit'],
+    },
+    {
+      kit: 'gogin.standard',
+      name: 'enterprise-gin',
+      extraArgs: [],
+      expectedFiles: ['go.mod', 'cmd/server/main.go', '.rapidkit/project.json', 'rapidkit'],
+    },
+    {
+      kit: 'springboot.standard',
+      name: 'enterprise-spring',
+      extraArgs: ['--java-version', '21'],
+      expectedFiles: ['pom.xml', 'src/main/resources/application.yml', '.rapidkit/project.json', 'rapidkit'],
+    },
+    {
+      kit: 'dotnet.webapi.clean',
+      name: 'enterprise-dotnet',
+      extraArgs: ['--target-framework', 'net8.0'],
+      expectedFiles: ['src/Program.cs', 'src/enterprise-dotnet.csproj', '.rapidkit/project.json', 'rapidkit'],
+    },
+  ];
+
+  try {
+    for (const scenario of scenarios) {
+      const args = [
+        cliPath,
+        'create',
+        'project',
+        scenario.kit,
+        scenario.name,
+        '--output',
+        tempDir,
+        '--skip-git',
+        '--skip-install',
+        ...scenario.extraArgs,
+      ];
+      const result = spawnSync(process.execPath, args, {
+        cwd: tempDir,
+        encoding: 'utf8',
+        env: cliEnv(),
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      if (result.status !== 0) {
+        fail(
+          `${scenario.kit} smoke create failed with exit ${result.status}\n${result.stdout}\n${result.stderr}`
+        );
+      }
+      assertGeneratedProject(path.join(tempDir, scenario.name), scenario.expectedFiles);
+    }
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+
+  log(`verified ${scenarios.length} npm-backed create scenarios`);
+}
+
+function smokeCreateOfflineFallbackKits() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rapidkit-enterprise-fallback-'));
+  const scenarios = [
+    {
+      kit: 'fastapi.standard',
+      name: 'enterprise-fastapi',
+      expectedFiles: [
+        'pyproject.toml',
+        'src/main.py',
+        'src/routing/health.py',
+        'src/routing/examples.py',
+        'tests/test_health.py',
+        'tests/test_examples.py',
+        '.env.example',
+        '.rapidkit/project.json',
+        'rapidkit',
+      ],
+    },
+    {
+      kit: 'nestjs.standard',
+      name: 'enterprise-nestjs',
+      expectedFiles: [
+        'package.json',
+        'src/main.ts',
+        'src/examples/examples.module.ts',
+        '.env.example',
+        '.rapidkit/project.json',
+        'rapidkit',
+      ],
+    },
+  ];
+
+  try {
+    for (const scenario of scenarios) {
+      const result = spawnSync(
+        process.execPath,
+        [
+          cliPath,
+          'create',
+          'project',
+          scenario.kit,
+          scenario.name,
+          '--output',
+          tempDir,
+          '--skip-git',
+          '--skip-install',
+        ],
+        {
+          cwd: tempDir,
+          encoding: 'utf8',
+          env: cliEnv({
+            RAPIDKIT_FORCE_OFFLINE_CREATE_FALLBACK: '1',
+          }),
+          stdio: ['ignore', 'pipe', 'pipe'],
+        }
+      );
+      if (result.status !== 0) {
+        fail(
+          `${scenario.kit} offline fallback smoke failed with exit ${result.status}\n${result.stdout}\n${result.stderr}`
+        );
+      }
+      assertGeneratedProject(path.join(tempDir, scenario.name), scenario.expectedFiles);
+    }
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+
+  log(`verified ${scenarios.length} offline fallback create scenarios`);
+}
+
+for (const relativePath of [
+  'package.json',
+  'dist/index.js',
+  'contracts/runtime-command-surface.v1.json',
+  'contracts/extension-cli-compatibility.v1.json',
+  'data/modules-embeddings.json',
+]) {
+  assertFile(relativePath);
+}
+
+assertPackContents();
+assertCliContracts();
+smokeCreateNpmBackedKits();
+smokeCreateOfflineFallbackKits();
+
+log('enterprise package smoke passed');

package/scripts/prepack-enterprise.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const repoRoot = process.cwd();
+
+function fail(message) {
+  console.error(`[prepack-enterprise] ${message}`);
+  process.exit(1);
+}
+
+function runNode(args, label, extraEnv = {}) {
+  console.log(`[prepack-enterprise] ${label}`);
+  execFileSync(process.execPath, args, {
+    cwd: repoRoot,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      ...extraEnv,
+      npm_config_user_agent: process.env.npm_config_user_agent || 'npm/10 rapidkit-prepack',
+    },
+  });
+}
+
+const tsupCli = path.join(repoRoot, 'node_modules', 'tsup', 'dist', 'cli-default.js');
+if (!fs.existsSync(tsupCli)) {
+  fail(`missing tsup CLI at ${tsupCli}; run npm ci before packaging`);
+}
+
+runNode([tsupCli], 'building dist');
+runNode(['scripts/prepare-mock-embeddings.mjs'], 'preparing packaged embeddings');
+runNode(['scripts/verify-package-cli.mjs'], 'verifying bundled CLI command ownership');
+runNode(['scripts/enterprise-package-smoke.mjs'], 'running enterprise package smoke', {
+  RAPIDKIT_ENTERPRISE_PREPACK: '1',
+});
+
+console.log('[prepack-enterprise] prepack checks passed');

package/templates/generator.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * RapidKit Project Generator
+ * This script is called by the rapidkit CLI to generate projects
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { execSync } = require('child_process');
+
+const TEMPLATES_DIR = path.join(__dirname, 'templates');
+
+async function generateProject(projectPath, template, useDefaults, skipGit, skipInstall) {
+  const projectName = path.basename(projectPath);
+  const templateDir = template === 'nestjs' ? 'nestjs-standard' : 'fastapi-standard';
+  const templatePath = path.join(TEMPLATES_DIR, templateDir);
+
+  // Check template exists
+  try {
+    await fs.access(templatePath);
+  } catch {
+    console.error('❌ Template not found:', templateDir);
+    process.exit(1);
+  }
+
+  // Create project directory
+  await fs.mkdir(projectPath, { recursive: true });
+
+  // Build context
+  const context = {
+    project_name: template === 'nestjs' 
+      ? projectName.replace(/_/g, '-').toLowerCase() 
+      : projectName.replace(/-/g, '_').toLowerCase(),
+    author: process.env.USER || 'RapidKit User',
+    description: template === 'nestjs' 
+      ? 'NestJS application generated with RapidKit' 
+      : 'FastAPI service generated with RapidKit',
+    app_version: '0.1.0',
+    license: 'MIT',
+    package_manager: 'npm',
+    created_at: new Date().toISOString(),
+    rapidkit_version: require('./config.json').rapidkit_version || '0.12.0',
+  };
+
+  // Copy and render template files
+  await copyTemplateDir(templatePath, projectPath, context);
+
+  console.log('✅ Project files created!');
+
+  // Git initialization
+  if (!skipGit) {
+    try {
+      execSync('git init', { cwd: projectPath, stdio: 'pipe' });
+      execSync('git add .', { cwd: projectPath, stdio: 'pipe' });
+      const commitMsg = 'Initial commit: ' + (template === 'nestjs' ? 'NestJS' : 'FastAPI') + ' project via RapidKit';
+      execSync(`git commit -m "${commitMsg}"`, { cwd: projectPath, stdio: 'pipe' });
+      console.log('✅ Git repository initialized');
+    } catch (e) {
+      console.log('⚠️  Could not initialize git');
+    }
+  }
+
+  // Install dependencies
+  if (!skipInstall) {
+    if (template === 'nestjs') {
+      console.log('📦 Installing dependencies...');
+      try {
+        execSync('npm install', { cwd: projectPath, stdio: 'inherit' });
+        console.log('✅ Dependencies installed');
+      } catch {
+        console.log('⚠️  Could not install dependencies. Run npm install manually.');
+      }
+    }
+  }
+
+  // Success message
+  const templateName = template === 'nestjs' ? 'NestJS' : 'FastAPI';
+  console.log('');
+  console.log('✨ ' + templateName + ' project created successfully!');
+  console.log('');
+  console.log('🚀 Get started:');
+  console.log('  cd ' + projectName);
+  if (template === 'fastapi') {
+    console.log('  rapidkit init    # poetry install');
+    console.log('  rapidkit dev     # Start dev server');
+  } else {
+    if (skipInstall) {
+      console.log('  rapidkit init    # npm install');
+    }
+    console.log('  cp .env.example .env');
+    console.log('  rapidkit dev     # Start dev server');
+  }
+  console.log('');
+}
+
+function renderTemplate(content, context) {
+  let result = content;
+  
+  for (const [key, value] of Object.entries(context)) {
+    // Simple variable replacement: {{ key }}
+    const simpleRegex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g');
+    result = result.replace(simpleRegex, String(value));
+    
+    // With replace filter: {{ key | replace('a', 'b') }}
+    const replaceRegex = new RegExp(
+      `\\{\\{\\s*${key}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\}\\}`,
+      'g'
+    );
+    result = result.replace(replaceRegex, (match, from, to) => {
+      return String(value).replace(new RegExp(from, 'g'), to);
+    });
+    
+    // With lower filter: {{ key | lower }}
+    const lowerRegex = new RegExp(`\\{\\{\\s*${key}\\s*\\|\\s*lower\\s*\\}\\}`, 'g');
+    result = result.replace(lowerRegex, String(value).toLowerCase());
+    
+    // Combined: {{ key | replace('a', 'b') | lower }}
+    const combinedRegex = new RegExp(
+      `\\{\\{\\s*${key}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\|\\s*lower\\s*\\}\\}`,
+      'g'
+    );
+    result = result.replace(combinedRegex, (match, from, to) => {
+      return String(value).replace(new RegExp(from, 'g'), to).toLowerCase();
+    });
+  }
+  
+  return result;
+}
+
+async function copyTemplateDir(src, dest, context) {
+  const entries = await fs.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destName = entry.name.replace(/\.j2$/, '');
+    const destPath = path.join(dest, destName);
+
+    if (entry.isDirectory()) {
+      await fs.mkdir(destPath, { recursive: true });
+      await copyTemplateDir(srcPath, destPath, context);
+    } else {
+      let content = await fs.readFile(srcPath, 'utf-8');
+
+      // Render template if it's a .j2 file
+      if (entry.name.endsWith('.j2')) {
+        content = renderTemplate(content, context);
+      }
+
+      await fs.writeFile(destPath, content);
+
+      // Make scripts executable
+      if (destName === 'rapidkit' || (destName.endsWith('.py') && destPath.includes('.rapidkit'))) {
+        await fs.chmod(destPath, 0o755);
+      }
+    }
+  }
+}
+
+// Main
+const args = process.argv.slice(2);
+const projectPath = args[0];
+const template = args[1] || 'fastapi';
+const useDefaults = args.includes('--yes');
+const skipGit = args.includes('--skip-git');
+const skipInstall = args.includes('--skip-install');
+
+if (!projectPath) {
+  console.error('Usage: node generator.js <project-path> <template> [--yes] [--skip-git] [--skip-install]');
+  process.exit(1);
+}
+
+generateProject(projectPath, template, useDefaults, skipGit, skipInstall).catch(err => {
+  console.error('Error:', err);
+  process.exit(1);
+});