@team-codeme/crud-forge 0.0.0-stage → 1.0.0

package/src/generator/project-output.js

@@ -0,0 +1,126 @@
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+const inquirer = require('inquirer');
+const { generate } = require('./index');
+const { mergeContent } = require('../utils/merger');
+
+function inside(root, file) {
+  const relative = path.relative(root, file);
+  return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function filesIn(directory) {
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+    const file = path.join(directory, entry.name);
+    if (entry.isSymbolicLink()) throw new Error(`Cannot publish a generated symlink: ${file}`);
+    return entry.isDirectory() ? filesIn(file) : [file];
+  });
+}
+
+function checkDestination(root, file) {
+  let current = file;
+  while (inside(root, current)) {
+    if (fs.existsSync(current) || fs.lstatSync(current, { throwIfNoEntry: false })) {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) throw new Error(`Refusing to write through symlink "${current}".`);
+      if (current !== file && !stat.isDirectory()) throw new Error(`Expected a directory at "${current}".`);
+      if (current === file && !stat.isFile()) throw new Error(`Expected a file at "${current}".`);
+    }
+    if (current === root) break;
+    current = path.dirname(current);
+  }
+}
+
+// The old engine performs multi-pass transformations of the starter. Complete those
+// privately, then apply policy once to each final file (including binary assets).
+async function generateProject(parsed, config, { configPath, inputPath, options = {} } = {}) {
+  require('../config/field-preferences').validateFieldPreferences(config, parsed.entities, configPath || config._configPath || 'fields configuration');
+  const output = path.resolve(config.output.directory);
+  const policy = config.output.overwritePolicy || 'fail';
+  for (const key of ['routesFile', 'navigationFile']) {
+    if (config.fuse?.[key] && !inside(output, path.resolve(output, config.fuse[key]))) {
+      throw new Error(`fuse.${key} must be inside the output project: ${config.fuse[key]}`);
+    }
+  }
+  const stage = await fs.mkdtemp(path.join(os.tmpdir(), 'crudforge-generate-'));
+  try {
+    const staged = JSON.parse(JSON.stringify(config));
+    staged.output.directory = stage;
+    staged.output.overwritePolicy = 'overwrite';
+    // The source config is developer-owned, not a generated snapshot.
+    if (configPath && inside(output, configPath)) staged.output.embedConfig = false;
+    staged.git = { ...staged.git, enabled: false };
+    staged.dryRun = false;
+    const stats = await generate(parsed, staged);
+    // Snapshots describe the real project, never the temporary staging directory.
+    const { formatEmbeddableYaml } = require('./embed-config');
+    for (const relative of ['config/crudforge.config.yml', '.crudforge/config.yaml']) {
+      const snapshot = path.join(stage, relative);
+      if (fs.existsSync(snapshot)) await fs.writeFile(snapshot, formatEmbeddableYaml({
+        ...config, output: { ...config.output, overwritePolicy: policy },
+      }));
+    }
+    // Preserve legacy credential flags, but prepare their files only after schema validation.
+    if (!config.dryRun && (options.kcUsername || options.kcPassword)) {
+      const { applyDeveloperKeycloakOptions } = require('../commands/keycloak-options');
+      await applyDeveloperKeycloakOptions(staged, options, { outputDir: stage, cwd: stage });
+    }
+    const changes = [];
+    for (const source of filesIn(stage)) {
+      const relative = path.relative(stage, source);
+      const target = path.join(output, relative);
+      if ([configPath, inputPath].filter(Boolean).some(file => path.resolve(file) === target)) continue;
+      // Never generate over other editable project input files either.
+      if (/^(config|gdl)[/\\]/.test(relative) && fs.existsSync(target)) continue;
+      checkDestination(output, target);
+      const content = fs.readFileSync(source);
+      const exists = fs.existsSync(target);
+      const old = exists ? fs.readFileSync(target) : null;
+      if (old?.equals(content)) continue;
+      changes.push({ source, target, relative, content, old });
+    }
+    const conflicts = changes.filter(change => change.old !== null);
+    if (!config.dryRun && conflicts.length && (policy === 'fail' || (policy === 'ask' && !process.stdout.isTTY))) {
+      throw new Error(`Existing application files differ:\n${conflicts.map(c => '  ' + c.target).join('\n')}\nNo project files were changed. Choose --overwrite-policy ask, skip, merge, or overwrite explicitly.`);
+    }
+    const dryRunReport = { newFiles: [], modifiedFiles: [] };
+    for (const change of changes) {
+      const binary = !Buffer.from(change.content.toString('utf8')).equals(change.content) || change.content.includes(0);
+      if (config.dryRun) {
+        dryRunReport[change.old ? 'modifiedFiles' : 'newFiles'].push({
+          path: change.relative,
+          content: binary ? '[binary asset]' : change.content.toString('utf8'),
+          oldContent: change.old ? (binary ? '[binary asset]' : change.old.toString('utf8')) : undefined,
+        });
+        continue;
+      }
+      let action = change.old ? policy : 'overwrite';
+      if (action === 'ask') {
+        const answer = await inquirer.prompt([{
+          type: 'list', name: 'action', message: `Existing file: ${change.target}`,
+          choices: binary ? ['skip', 'overwrite'] : ['skip', 'merge', 'overwrite'],
+        }]);
+        action = answer.action;
+      }
+      if (action === 'skip') { change.skip = true; continue; }
+      // Merge cannot patch binaries (logos, sounds, fonts) — keep the existing file.
+      if (action === 'merge' && binary) { change.skip = true; continue; }
+      if (action === 'merge') change.content = Buffer.from(mergeContent(change.old.toString('utf8'), change.content.toString('utf8')));
+    }
+    if (!config.dryRun) {
+      for (const change of changes.filter(change => !change.skip)) {
+        await fs.ensureDir(path.dirname(change.target));
+        await fs.writeFile(change.target, change.content);
+        await fs.chmod(change.target, fs.statSync(change.source).mode & 0o777);
+      }
+      if (config.fuse?.enabled) require('./team-pack').initGitRepository(output, config);
+    }
+    return { ...stats, fileCount: changes.filter(change => !change.skip).length,
+      dryRun: !!config.dryRun, dryRunReport: config.dryRun ? dryRunReport : null, conflicts: [] };
+  } finally {
+    await fs.remove(stage);
+  }
+}
+
+module.exports = { generateProject };

package/src/generator/team-pack.js

@@ -0,0 +1,220 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/**
+ * Seed Cursor / Codex / Antigravity / VS Code team folders into the generated Fuse root.
+ * Enabled by default via output.teamPack.enabled.
+ */
+function applyTeamPack(outputDir, config, writeOrPreview) {
+  const pack = config.output?.teamPack || {};
+  if (pack.enabled === false) {
+    return { applied: false, reason: 'output.teamPack.enabled=false' };
+  }
+
+  const cliRoot = path.resolve(__dirname, '../..');
+  const written = [];
+  const cursorSrc = path.join(cliRoot, '.cursor', 'agents');
+
+  if (pack.cursorAgents !== false) {
+    written.push(...copyAgentDir(
+      cursorSrc,
+      path.join(outputDir, '.cursor', 'agents'),
+      writeOrPreview
+    ));
+  }
+
+  if (pack.codexAgents !== false) {
+    const codexSrc = path.join(cliRoot, '.codex', 'agents');
+    const source = fs.existsSync(codexSrc) ? codexSrc : cursorSrc;
+    written.push(...copyAgentDir(source, path.join(outputDir, '.codex', 'agents'), writeOrPreview));
+  }
+
+  if (pack.antigravityAgents !== false) {
+    const antigravitySrc = path.join(cliRoot, '.agents', 'agents');
+    const source = fs.existsSync(antigravitySrc) ? antigravitySrc : cursorSrc;
+    written.push(...copyAgentDir(
+      source,
+      path.join(outputDir, '.agents', 'agents'),
+      writeOrPreview
+    ));
+    written.push(...writeAntigravityRules(source, outputDir, writeOrPreview));
+  }
+
+  if (pack.vscodeExtensions !== false) {
+    written.push(...writeVscodeTeamFiles(outputDir, writeOrPreview));
+  }
+
+  return { applied: true, files: written };
+}
+
+function copyAgentDir(srcDir, destDir, writeOrPreview) {
+  const written = [];
+  if (!fs.existsSync(srcDir)) {
+    return written;
+  }
+  const entries = fs.readdirSync(srcDir).filter((name) => name.endsWith('.md'));
+  for (const name of entries) {
+    const content = fs.readFileSync(path.join(srcDir, name), 'utf8');
+    const target = path.join(destDir, name);
+    writeOrPreview(target, content);
+    written.push(target);
+  }
+  return written;
+}
+
+/**
+ * Antigravity discovers workspace specialists under `.agents/rules/*.md`
+ * (model_decision). Agent personas also land in `.agents/agents/` via copyAgentDir.
+ */
+function writeAntigravityRules(srcDir, outputDir, writeOrPreview) {
+  const written = [];
+  if (!fs.existsSync(srcDir)) {
+    return written;
+  }
+  const entries = fs.readdirSync(srcDir).filter((name) => name.endsWith('.md'));
+  for (const name of entries) {
+    const raw = fs.readFileSync(path.join(srcDir, name), 'utf8');
+    const { description, body } = parseAgentMarkdown(raw);
+    const content = [
+      '---',
+      'trigger: model_decision',
+      `description: ${yamlDoubleQuoted(description || name.replace(/\.md$/, ''))}`,
+      '---',
+      '',
+      body.trimStart(),
+    ].join('\n');
+    const target = path.join(outputDir, '.agents', 'rules', name);
+    writeOrPreview(target, content.endsWith('\n') ? content : `${content}\n`);
+    written.push(target);
+  }
+  return written;
+}
+
+function parseAgentMarkdown(raw) {
+  const match = String(raw || '').match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    return { description: '', body: String(raw || '') };
+  }
+  const front = match[1];
+  const body = match[2] || '';
+  const descLine = front.split(/\r?\n/).find((line) => /^\s*description\s*:/.test(line));
+  let description = '';
+  if (descLine) {
+    description = descLine.replace(/^\s*description\s*:\s*/, '').trim();
+    if (
+      (description.startsWith('"') && description.endsWith('"')) ||
+      (description.startsWith("'") && description.endsWith("'"))
+    ) {
+      description = description.slice(1, -1);
+    }
+  }
+  return { description, body };
+}
+
+function yamlDoubleQuoted(value) {
+  return `"${String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function writeVscodeTeamFiles(outputDir, writeOrPreview) {
+  const written = [];
+  const extensionsDir = path.join(outputDir, '.vscode', 'extensions');
+  const readme = `# Keep-team VS Code / Cursor extensions
+
+Recommended extensions are listed in \`../extensions.json\`.
+Install them via the Extensions view ("Show Recommended Extensions").
+
+This folder is reserved for team extension notes and local extension packs.
+Do not commit proprietary VSIX binaries unless your team policy requires it.
+`;
+  writeOrPreview(path.join(extensionsDir, 'README.md'), readme);
+  written.push(path.join(extensionsDir, 'README.md'));
+
+  const extensionsJson = {
+    recommendations: [
+      'angular.ng-template',
+      'dbaeumer.vscode-eslint',
+      'esbenp.prettier-vscode',
+      'ms-playwright.playwright',
+    ],
+  };
+  writeOrPreview(
+    path.join(outputDir, '.vscode', 'extensions.json'),
+    `${JSON.stringify(extensionsJson, null, 2)}\n`
+  );
+  written.push(path.join(outputDir, '.vscode', 'extensions.json'));
+
+  const settings = {
+    'editor.formatOnSave': true,
+    'editor.defaultFormatter': 'esbenp.prettier-vscode',
+    'files.exclude': {
+      '**/.angular': true,
+    },
+  };
+  writeOrPreview(
+    path.join(outputDir, '.vscode', 'settings.json'),
+    `${JSON.stringify(settings, null, 2)}\n`
+  );
+  written.push(path.join(outputDir, '.vscode', 'settings.json'));
+
+  return written;
+}
+
+/**
+ * Initialize git and set origin when project.repositoryUrl is set.
+ * Does not push. Does not force-change an existing remote.
+ */
+function initGitRepository(outputDir, config) {
+  const url = String(config.project?.repositoryUrl || config.git?.repositoryUrl || '').trim();
+  if (!url) {
+    return { initialized: false, reason: 'no project.repositoryUrl' };
+  }
+  if (config.git?.enabled === false) {
+    return { initialized: false, reason: 'git.enabled=false' };
+  }
+  if (config.dryRun) {
+    return { initialized: false, dryRun: true, wouldUse: url };
+  }
+
+  const gitDir = path.join(outputDir, '.git');
+  if (!fs.existsSync(gitDir)) {
+    const init = spawnSync('git', ['init'], { cwd: outputDir, encoding: 'utf8' });
+    if (init.status !== 0) {
+      throw new Error(`git init failed in ${outputDir}: ${init.stderr || init.stdout}`);
+    }
+  }
+
+  const remotes = spawnSync('git', ['remote'], { cwd: outputDir, encoding: 'utf8' });
+  const remoteList = (remotes.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  if (!remoteList.includes('origin')) {
+    const add = spawnSync('git', ['remote', 'add', 'origin', url], {
+      cwd: outputDir,
+      encoding: 'utf8',
+    });
+    if (add.status !== 0) {
+      throw new Error(`git remote add origin failed: ${add.stderr || add.stdout}`);
+    }
+    return { initialized: true, remote: 'origin', url, createdRemote: true };
+  }
+
+  const existing = spawnSync('git', ['remote', 'get-url', 'origin'], {
+    cwd: outputDir,
+    encoding: 'utf8',
+  });
+  const current = (existing.stdout || '').trim();
+  if (current && current !== url) {
+    return {
+      initialized: true,
+      remote: 'origin',
+      url: current,
+      createdRemote: false,
+      warning: `origin already points to ${current}; left unchanged (config wanted ${url})`,
+    };
+  }
+  return { initialized: true, remote: 'origin', url: current || url, createdRemote: false };
+}
+
+module.exports = {
+  applyTeamPack,
+  initGitRepository,
+};

package/src/index.js

@@ -0,0 +1,68 @@
+const _ = require('lodash');
+const { loadConfig } = require('./config/load-config');
+const { parseJdl } = require('./parser/jdl-parser');
+const { parseGdl } = require('./parser/gdl-parser');
+const { generate } = require('./generator');
+
+/**
+ * Main programmatic entry point for generating code.
+ * @param {string} fileContent - Raw content of the JDL/GDL file.
+ * @param {object} options - Custom options to override config.
+ */
+async function generateFromSource(fileContent, options = {}) {
+  const { config } = await loadConfig(process.cwd(), options.configPath);
+  
+  // Merge options parameter overrides
+  if (options.microservice) config.api.microservice = options.microservice;
+  if (options.outputDirectory) config.output.directory = options.outputDirectory;
+  if (options.validation !== undefined) config.validation = options.validation;
+  if (options.dryRun !== undefined) config.dryRun = options.dryRun;
+  if (options.generate !== undefined) {
+    config.generate = { ...config.generate, ...options.generate };
+  }
+  if (options.fuse !== undefined) {
+    config.fuse = _.defaultsDeep({}, options.fuse, config.fuse);
+  }
+  if (options.mock !== undefined) {
+    config.mock = _.defaultsDeep({}, options.mock, config.mock);
+  }
+  if (options.ui !== undefined) {
+    config.ui = _.defaultsDeep({}, options.ui, config.ui);
+  }
+  if (options.auth !== undefined) {
+    config.auth = _.defaultsDeep({}, options.auth, config.auth);
+  }
+  if (config.auth) {
+    const { stripSecretsForGenerate, deriveAuthUrls } = require('./config/auth-config');
+    deriveAuthUrls(config.auth);
+    config.auth = stripSecretsForGenerate(config.auth);
+  }
+  if (options.iam !== undefined) {
+    config.iam = _.defaultsDeep({}, options.iam, config.iam);
+  }
+  if (options.proxy !== undefined) {
+    config.proxy = _.defaultsDeep({}, options.proxy, config.proxy || {});
+  }
+
+  const isGdl = options.fileType === 'gdl' || (options.filePath && options.filePath.endsWith('.gdl'));
+  
+  const { requireValidSchema, formatDiagnostics } = require('./validator/diagnostics');
+  const checked = requireValidSchema(fileContent, {file: options.filePath || '<schema>', isGdl, config});
+  if (checked.diagnostics.length) console.warn(formatDiagnostics(checked.diagnostics));
+  const parsed = checked.parsed;
+
+  const stats = await generate(parsed, config);
+  return {
+    config,
+    parsed,
+    stats
+  };
+}
+
+module.exports = {
+  loadConfig,
+  parseJdl,
+  parseGdl,
+  generate,
+  generateFromSource
+};

package/src/parser/gdl-parser.js

@@ -0,0 +1,169 @@
+const _ = require('lodash');
+const {
+  DEFAULT_AUDIT_FIELDS,
+  ACTIVE_STATUS_FIELD,
+  parseEntityAnnotations
+} = require('./jdl-parser');
+
+/**
+ * Normalizes GDL field types to JDL equivalents.
+ */
+function normalizeGdlType(gdlType) {
+  const typeMappings = {
+    string: 'String',
+    bool: 'Boolean',
+    int: 'Integer',
+    long: 'Long',
+    double: 'Double',
+    bigDecimal: 'BigDecimal',
+    date: 'LocalDate',
+    datetime: 'Instant'
+  };
+  return typeMappings[gdlType] || gdlType;
+}
+
+/**
+ * Parses GDL file contents.
+ * @param {string} gdlContent - Raw GDL content string.
+ * @param {object} preferences - Developer preferences configuration.
+ * @returns {{entities: Array, enums: Array, relationships: Array}}
+ */
+function parseGdl(gdlContent, preferences = {}) {
+  const entities = {};
+  const enums = {};
+  const relationships = [];
+
+  const cleanContent = gdlContent.replace(/\/\*[\s\S]*?\*\//g, '');
+
+  function isCommented(content, index) {
+    const lastNewline = content.lastIndexOf('\n', index);
+    const lineStart = lastNewline === -1 ? 0 : lastNewline + 1;
+    const line = content.substring(lineStart, index);
+    return line.trim().startsWith('//');
+  }
+
+  // 1. Parse Enums (Syntactically identical to JDL)
+  const enumRegex = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+  let enumMatch;
+  while ((enumMatch = enumRegex.exec(cleanContent)) !== null) {
+    if (isCommented(cleanContent, enumMatch.index)) continue;
+    const enumName = enumMatch[1];
+    const values = enumMatch[2]
+      .trim()
+      .split(',')
+      .map(v => v.trim().split('(')[0].trim())
+      .filter(Boolean);
+    enums[enumName] = { name: enumName, values: values.map(v => ({ name: v })) };
+  }
+
+  // Determine audit fields based on config preferences
+  let auditFieldsToUse = DEFAULT_AUDIT_FIELDS;
+  if (preferences.fields && preferences.fields.audit && Array.isArray(preferences.fields.audit.names)) {
+    auditFieldsToUse = preferences.fields.audit.names.map(name => {
+      const type = (name.toLowerCase().endsWith('date') || /(?:At|_at)$/.test(name)) ? 'Instant' : 'String';
+      return { fieldName: name, fieldType: type, fieldTypeIsEnum: false, fieldValidateRules: [], comment: null };
+    });
+  }
+
+  // 2. Parse Entities and Fields
+  const entityRegex = /((?:@\w+\s+)*)entity\s+(\w+)\s*\{([^}]+)\}/g;
+  let entityMatch;
+  while ((entityMatch = entityRegex.exec(cleanContent)) !== null) {
+    if (isCommented(cleanContent, entityMatch.index)) continue;
+
+    const annotations = parseEntityAnnotations(entityMatch[1] || '');
+    const flags = new Set(annotations);
+    const hasAuditAnnotation = flags.has('Audited');
+    const hasActiveStatus = flags.has('ActiveStatus');
+    const hasSearchable = flags.has('Searchable');
+    const entityName = entityMatch[2];
+    const fieldsContent = entityMatch[3];
+
+    const fields = [];
+    const fieldLines = fieldsContent
+      .split('\n')
+      .map(l => l.trim())
+      .filter(line => line && !line.startsWith('//'));
+
+    fieldLines.forEach(line => {
+      // GDL field syntax: <fieldType> <fieldName> [validations] [comment]
+      const fieldMatch = line.match(/^([\w<>]+)\s+(\w+)(.*)/);
+      if (fieldMatch) {
+        const rawFieldType = fieldMatch[1];
+        const fieldName = fieldMatch[2];
+        const restOfLine = fieldMatch[3] || '';
+
+        let validations = restOfLine;
+        let comment = null;
+
+        const commentIndex = restOfLine.indexOf('//');
+        if (commentIndex !== -1) {
+          validations = restOfLine.substring(0, commentIndex).trim();
+          comment = restOfLine.substring(commentIndex + 2).trim();
+        }
+
+        const fieldType = normalizeGdlType(rawFieldType);
+
+        fields.push({
+          fieldName,
+          fieldType,
+          fieldTypeIsEnum: !!enums[fieldType],
+          fieldValidateRules: validations.split(/\s+/).filter(Boolean),
+          comment
+        });
+      }
+    });
+
+    if (hasActiveStatus && !fields.some((f) => f.fieldName === 'isActive')) {
+      fields.push({ ...ACTIVE_STATUS_FIELD });
+    }
+
+    if (hasAuditAnnotation && preferences.fields?.audit?.enabled !== false) {
+      fields.push(...auditFieldsToUse);
+    }
+
+    entities[entityName] = {
+      name: entityName,
+      fields,
+      annotations,
+      searchable: hasSearchable,
+      activeStatus: hasActiveStatus,
+      audited: hasAuditAnnotation
+    };
+  }
+
+  // 3. Parse Relationships
+  const relBlockRegex = /relationship\s+(OneToOne|ManyToOne|OneToMany|ManyToMany)\s*\{([\s\S]*?)\n\}/g;
+  let blockMatch;
+  while ((blockMatch = relBlockRegex.exec(cleanContent)) !== null) {
+    if (isCommented(cleanContent, blockMatch.index)) continue;
+    const relType = blockMatch[1];
+    const blockContent = blockMatch[2];
+    const lines = blockContent
+      .split('\n')
+      .map(l => l.trim())
+      .filter(line => line && !line.startsWith('//'));
+
+    lines.forEach(line => {
+      const relLineRegex = /^(\w+)(?:\{([\w()]+)\})?\s+to\s+(\w+)(?:\{([\w()]+)\})?/;
+      const lineMatch = line.match(relLineRegex);
+      if (lineMatch) {
+        relationships.push({
+          type: relType,
+          from: { name: lineMatch[1], fieldName: lineMatch[2] },
+          to: { name: lineMatch[3], fieldName: lineMatch[4] }
+        });
+      }
+    });
+  }
+
+  return {
+    entities: Object.values(entities),
+    enums: Object.values(enums),
+    relationships
+  };
+}
+
+module.exports = {
+  parseGdl
+};