@shanyucoder/flowgrid 0.1.5 → 0.1.9

package/bin/lib/agent-profiles.mjs

@@ -5,6 +5,16 @@ import * as path from 'node:path';
  * Sync builds one project staging bundle, then materializes per agent dir + overlay.
  */
 
+/** @deprecated init option removed — maps to Antigravity IDE profile only */
+const LEGACY_AGENT_ALIASES = {
+  gemini_antigravity: 'antigravity',
+};
+
+/** @param {string} agent */
+export function resolveCanonicalAgentId(agent) {
+  return LEGACY_AGENT_ALIASES[agent] ?? agent;
+}
+
 /** @type {Record<string, {
  *   id: string;
  *   dirName: string;
@@ -26,16 +36,26 @@ export const AGENT_PROFILES = {
     overlayFile: 'AGENTS.md',
     registryPathPrefix: '.cursor',
   },
-  gemini_antigravity: {
-    id: 'gemini_antigravity',
+  gemini: {
+    id: 'gemini',
     dirName: '.agents',
-    mcpFile: 'mcp_config.json',
-    label: 'Antigravity',
+    mcpFile: 'mcp.json',
+    label: 'Gemini (CLI / VS Code extension)',
     readTool: 'Read',
     writeTool: 'Write',
     overlayFile: 'AGENTS.md',
     registryPathPrefix: '.agents',
   },
+  antigravity: {
+    id: 'antigravity',
+    dirName: '.antigravity',
+    mcpFile: 'mcp_config.json',
+    label: 'Google Antigravity IDE',
+    readTool: 'Read',
+    writeTool: 'Write',
+    overlayFile: 'AGENTS.md',
+    registryPathPrefix: '.antigravity',
+  },
   claude: {
     id: 'claude',
     dirName: '.claude',
@@ -110,7 +130,10 @@ const DEFAULT_PROFILE = {
 };
 
 export function getAgentProfile(agent) {
-  return AGENT_PROFILES[agent] ?? { ...DEFAULT_PROFILE, id: agent, label: agent };
+  const id = resolveCanonicalAgentId(agent);
+  const profile = AGENT_PROFILES[id];
+  if (profile) return profile;
+  return { ...DEFAULT_PROFILE, id: agent, label: agent };
 }
 
 export function resolveAgentDir(agent) {
@@ -123,5 +146,6 @@ export function resolveAgentMcpConfigPath(agent, agentDir) {
 }
 
 export function agentHarnessOverlayPath(packageRoot, agent) {
-  return path.join(packageRoot, 'harness', 'agents', agent);
+  const id = resolveCanonicalAgentId(agent);
+  return path.join(packageRoot, 'harness', 'agents', id);
 }

package/bin/lib/audit-run.mjs

@@ -34,7 +34,7 @@ export function printAuditHelp() {
     '  testcase   TC-*.yaml (v2) or legacy plan; --bundle cross-ref bundle',
     '  fe-be      bundle apiRef vs 01-backend-spec alignment',
     '  scenario   cross-flow SC screens vs cases/** TC coverage',
-    '  e2e        TC YAML vs Playwright (--e2e-root, --tests-docs)',
+    '  e2e        TC YAML vs Playwright (--id, config/MCP e2eRoot, --tests-docs)',
     '  legacy     legacy adoption / target-id gaps',
     '',
     'Examples:',

package/bin/lib/cli-update.mjs

@@ -26,6 +26,32 @@ function hasCommand(cmd) {
   return res.status === 0;
 }
 
+/**
+ * @param {string} root realpath of package install
+ * @param {string} pnpmRoot output of `pnpm root -g`
+ */
+export function isPnpmGlobalPackageRoot(root, pnpmRoot) {
+  if (!pnpmRoot || !fs.existsSync(pnpmRoot)) return false;
+  const pnpmReal = fs.realpathSync(pnpmRoot);
+  const pnpmGlobalBase = path.dirname(pnpmReal);
+  if (
+    root === pnpmReal ||
+    root.startsWith(pnpmReal + path.sep) ||
+    root.startsWith(pnpmGlobalBase + path.sep)
+  ) {
+    return true;
+  }
+  const slash = NPM_PACKAGE.indexOf('/');
+  const linkPath = path.join(pnpmReal, NPM_PACKAGE.slice(0, slash), NPM_PACKAGE.slice(slash + 1));
+  if (!fs.existsSync(linkPath)) return false;
+  try {
+    const linkReal = fs.realpathSync(linkPath);
+    return root === linkReal || root.startsWith(linkReal + path.sep);
+  } catch {
+    return false;
+  }
+}
+
 function readPackageVersion(packageRoot) {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
@@ -54,11 +80,8 @@ export function detectInstallKind(packageRoot) {
   }
 
   const pnpmRoot = tryCommand('pnpm', ['root', '-g']);
-  if (pnpmRoot && fs.existsSync(pnpmRoot)) {
-    const pnpmReal = fs.realpathSync(pnpmRoot);
-    if (root.startsWith(pnpmReal + path.sep) || root === pnpmReal) {
-      return 'pnpm-global';
-    }
+  if (pnpmRoot && isPnpmGlobalPackageRoot(root, pnpmRoot)) {
+    return 'pnpm-global';
   }
 
   const npmPrefix = tryCommand('npm', ['prefix', '-g']);
@@ -227,17 +250,34 @@ export function runCliUpdate(opts) {
       }
       code = updateGlobalPackageManager('npm', packageRoot, repo);
       break;
-    default:
+    default: {
+      let pkgName = '';
+      try {
+        pkgName = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8')).name ?? '';
+      } catch {
+        /* ignore */
+      }
+      if (pkgName === NPM_PACKAGE && hasCommand('pnpm')) {
+        log(`Nhận diện ${NPM_PACKAGE} (layout pnpm) — nâng cấp qua pnpm global…`);
+        code = updateGlobalPackageManager('pnpm', packageRoot, repo);
+        break;
+      }
+      if (pkgName === NPM_PACKAGE && hasCommand('npm')) {
+        log(`Nhận diện ${NPM_PACKAGE} — nâng cấp qua npm global…`);
+        code = updateGlobalPackageManager('npm', packageRoot, repo);
+        break;
+      }
       log('Không xác định được cách cài. Thử một trong các lệnh sau:');
       if (isPackageOnRegistry()) {
-        log(`  pnpm add -g ${NPM_PACKAGE}`);
-        log(`  npm install -g ${NPM_PACKAGE}`);
+        log(`  pnpm add -g ${NPM_PACKAGE}@latest ${PNPM_ALLOW_BUILD}`);
+        log(`  npm install -g ${NPM_PACKAGE}@latest`);
       } else {
         log(`  pnpm add -g ${GITHUB_PKG(repo)} ${PNPM_ALLOW_BUILD}`);
         log(`  npm install -g ${GITHUB_PKG(repo)}`);
       }
       log('  Hoặc chạy lại install.sh (Linux/WSL) sau khi đã gỡ bản cũ.');
       return 1;
+    }
   }
 
   if (code !== 0) {

package/bin/lib/doctor.mjs

@@ -1,17 +1,18 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { resolveAgentDir, writeRootAgentsMd } from './harness-overlay.mjs';
+import { getAgentProfile, resolveCanonicalAgentId } from './agent-profiles.mjs';
 import { loadProjectConfig, runHarnessSync } from './harness-sync.mjs';
 import { AUDIT_ENGINES } from './audit-run.mjs';
+import { compareConfigAndRepoMaps } from './repo-maps-align.mjs';
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
 
 function mcpConfigPath(agentDir, agent) {
-  return agent === 'gemini_antigravity'
-    ? path.join(agentDir, 'mcp_config.json')
-    : path.join(agentDir, 'mcp.json');
+  const { mcpFile } = getAgentProfile(agent);
+  return path.join(agentDir, mcpFile);
 }
 
 function walkHasUnrenderedPlaceholders(dir) {
@@ -65,6 +66,12 @@ export function runDoctor(opts) {
   const config = loadProjectConfig(projectRoot);
   const agents = config.agents?.length ? config.agents : [];
 
+  if (config.agents?.includes('gemini_antigravity')) {
+    warnings.push(
+      'config.agents has deprecated gemini_antigravity — use gemini (.agents) and/or antigravity (.antigravity); run flowgrid harness sync after updating config.',
+    );
+  }
+
   if (!agents.length) {
     warnings.push('config.agents is empty — re-run init and select at least one agent.');
   }
@@ -78,6 +85,27 @@ export function runDoctor(opts) {
     config.type !== 'Document' &&
     Boolean(config.frontend?.docsRoot || config.backend?.docsRoot);
 
+  const needsTestsPointer =
+    config.type !== 'Test' &&
+    Boolean(config.frontend?.testsRoot || config.backend?.testsRoot);
+
+  const e2eRoot = config.frontend?.e2eRoot ?? config.backend?.e2eRoot;
+  if (
+    (config.type === 'Frontend' || config.type === 'Fullstack' || config.type === 'Backend') &&
+    needsTestsPointer &&
+    !e2eRoot
+  ) {
+    warnings.push(
+      'e2eRoot unset (frontend.e2eRoot or backend.e2eRoot) — re-run init or set in .flowgrid/config.json; harness sync sets FLOWGRID_E2E_ROOT',
+    );
+  }
+
+  if (!config.stack && (config.type === 'Frontend' || config.type === 'Backend' || config.type === 'Fullstack')) {
+    warnings.push(
+      'config missing stack/commands (ArtifactGraph allowlist) — re-run flowgrid init or merge stacks/*.json fields into config.json',
+    );
+  }
+
   for (const agent of agents) {
     const relDir = resolveAgentDir(agent);
     const agentDir = path.join(projectRoot, relDir);
@@ -107,6 +135,21 @@ export function runDoctor(opts) {
       );
     }
 
+    if (needsTestsPointer && !env.FLOWGRID_TESTS_DOC) {
+      issues.push(
+        `${relDir}: FLOWGRID_TESTS_DOC unset (tests-docs hub pointer for cases:gate / audit scenario / testcase:gen)`,
+      );
+    }
+
+    const needsE2ePointer =
+      needsTestsPointer &&
+      Boolean(config.frontend?.e2eRoot || config.backend?.e2eRoot);
+    if (needsE2ePointer && !env.FLOWGRID_E2E_ROOT) {
+      warnings.push(
+        `${relDir}: FLOWGRID_E2E_ROOT unset (automation root for audit e2e / testcase:gen — run harness sync)`,
+      );
+    }
+
     if (config.type === 'Document' && !env.FLOWGRID_DEFAULT_LANG && config.defaultLanguage) {
       warnings.push(
         `${relDir}: FLOWGRID_DEFAULT_LANG missing though config.defaultLanguage is set`,
@@ -130,6 +173,50 @@ export function runDoctor(opts) {
     for (const f of stale) {
       issues.push(`Unrendered {{FLOWGRID_*}} in ${path.relative(projectRoot, f)}`);
     }
+
+    const skillsDir = path.join(agentDir, 'skills');
+    if (!fs.existsSync(skillsDir)) {
+      issues.push(
+        `${relDir}: missing skills/ — run \`flowgrid harness sync --agent=${resolveCanonicalAgentId(agent)}\``,
+      );
+    } else {
+      const skillDirs = fs
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory());
+      if (skillDirs.length === 0) {
+        issues.push(
+          `${relDir}: skills/ is empty — run \`flowgrid harness sync --agent=${agent}\``,
+        );
+      }
+    }
+
+    const canonical = resolveCanonicalAgentId(agent);
+    if (canonical === 'antigravity') {
+      const hintPath = path.join(agentDir, 'rules', 'antigravity-mcp.mdc');
+      if (!fs.existsSync(hintPath)) {
+        warnings.push(`${relDir}: missing antigravity-mcp rule — re-run harness sync`);
+      }
+    }
+    if (canonical === 'gemini') {
+      const hintPath = path.join(agentDir, 'rules', 'gemini-mcp.mdc');
+      if (!fs.existsSync(hintPath)) {
+        warnings.push(`${relDir}: missing gemini-mcp rule — re-run harness sync`);
+      }
+    }
+  }
+
+  if (fs.existsSync(path.join(projectRoot, 'platform-repos.local.json'))) {
+    const cmp = compareConfigAndRepoMaps(projectRoot);
+    for (const c of cmp.conflicts) {
+      warnings.push(
+        `platform-repos.local.json "${c.key}" ≠ .flowgrid/config.json — run \`flowgrid repo-maps align\``,
+      );
+    }
+    if (cmp.missingInMap.length) {
+      warnings.push(
+        `platform-repos.local.json missing keys: ${cmp.missingInMap.join(', ')} — run \`flowgrid repo-maps sync --from-config\``,
+      );
+    }
   }
 
   let fixed = false;

package/bin/lib/harness-overlay.mjs

@@ -1,6 +1,11 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getAgentProfile, resolveAgentDir, AGENT_PROFILES } from './agent-profiles.mjs';
+import {
+  getAgentProfile,
+  resolveAgentDir,
+  resolveCanonicalAgentId,
+  AGENT_PROFILES,
+} from './agent-profiles.mjs';
 
 export { resolveAgentDir, AGENT_PROFILES as AGENT_META };
 
@@ -27,9 +32,11 @@ export function renderHarnessPlaceholders(text, ctx) {
 const OVERLAY_EXTENSIONS = new Set(['.md', '.mdc']);
 
 export function applyHarnessOverlay(agentDir, agentId) {
-  const agent =
-    agentId ??
-    (path.basename(agentDir) === 'agents' ? 'gemini_antigravity' : path.basename(agentDir).replace(/^\./, ''));
+  const inferred =
+    path.basename(agentDir) === 'agents'
+      ? 'gemini'
+      : path.basename(agentDir).replace(/^\./, '');
+  const agent = resolveCanonicalAgentId(agentId ?? inferred);
   const ctx = buildOverlayContext(agent);
 
   const walk = (dir) => {
@@ -62,7 +69,7 @@ export function writeRootAgentsMd(projectRoot, agents) {
   for (const agent of agents) {
     const dir = resolveAgentDir(agent);
     const meta = getAgentProfile(agent);
-    const overlayPkg = `harness/agents/${agent}/` ;
+    const overlayPkg = `harness/agents/${resolveCanonicalAgentId(agent)}/`;
     lines.push(
       `- **${meta.label}** (\`${agent}\`): [\`${dir}/${meta.overlayFile}\`](${dir}/${meta.overlayFile}) · MCP \`${meta.mcpFile}\` · overlay package \`${overlayPkg}\``,
     );

package/bin/lib/harness-sync.mjs

@@ -6,6 +6,7 @@ import {
   agentHarnessOverlayPath,
   getAgentProfile,
   resolveAgentDir,
+  resolveCanonicalAgentId,
 } from './agent-profiles.mjs';
 import { applyHarnessOverlay, writeRootAgentsMd } from './harness-overlay.mjs';
 
@@ -18,10 +19,12 @@ export const CONSUMER_DOC_SKILL_NAMES = new Set([
   'grill-bqa',
   'grill-dev',
   'grill-docs',
-  'grill-common-spec',
   'qa-resolve',
   'api-spec',
   'api-update',
+  'grill-api-spec',
+  'grill-api',
+  'openapi',
 ]);
 
 export const CONSUMER_DOC_RULE_NAMES = new Set([
@@ -72,7 +75,16 @@ export function createCopyRecursive() {
     const items = fs.readdirSync(srcDir, { withFileTypes: true });
     for (const item of items) {
       if (
-        ['node_modules', '.git', 'dist', '.agents', '.gemini', '.cursor', '.flowgrid'].includes(
+        [
+          'node_modules',
+          '.git',
+          'dist',
+          '.agents',
+          '.antigravity',
+          '.gemini',
+          '.cursor',
+          '.flowgrid',
+        ].includes(
           item.name,
         )
       ) {
@@ -345,6 +357,7 @@ export function syncAgentHarness(opts) {
   const selectedType = config.type;
   const feDocRoot = config.frontend?.docsRoot ?? config.backend?.docsRoot ?? '';
   const feTestRoot = config.frontend?.testsRoot ?? config.backend?.testsRoot ?? '';
+  const feE2eRoot = config.frontend?.e2eRoot ?? config.backend?.e2eRoot ?? '';
   const feAdapter = config.frontend?.adapter ?? '';
   const beAdapter = config.backend?.adapter ?? '';
   const defaultLanguage = config.defaultLanguage;
@@ -354,6 +367,7 @@ export function syncAgentHarness(opts) {
     selectedType,
     feDocRoot: selectedType === 'Document' ? projectRoot : feDocRoot,
     feTestRoot: selectedType === 'Test' ? projectRoot : feTestRoot,
+    feE2eRoot,
     feAdapter,
     beAdapter,
     defaultLanguage,
@@ -366,7 +380,7 @@ export function syncAgentHarness(opts) {
     env: mcpEnv,
   });
 
-  applyHarnessOverlay(agentDir, agent);
+  applyHarnessOverlay(agentDir, resolveCanonicalAgentId(agent));
 
   return { agentDir, mcpEnv, profile };
 }

package/bin/lib/init-adapters.mjs

@@ -0,0 +1,75 @@
+// Adapter ids must match adapters/<id> and harness/.../adapters/<id> when present.
+
+export const FE_ADAPTER_OPTIONS = [
+  { value: 'nuxt4', label: 'Nuxt 4' },
+  { value: 'nextjs', label: 'Next.js' },
+  { value: 'dotnet-line', label: 'DotNet — line client (dotnet-line)' },
+  { value: 'custom', label: 'Custom (other Vue/React/Angular)' },
+];
+
+export const BE_ADAPTER_OPTIONS = [
+  { value: 'nestjs', label: 'NestJS' },
+  { value: 'fastapi', label: 'FastAPI' },
+  { value: 'laravel', label: 'Laravel' },
+  { value: 'dotnet-integration', label: 'DotNet — external/partner stack (dotnet-integration)' },
+  { value: 'custom', label: 'Custom backend stack' },
+];
+
+const FE_KNOWN = new Set(FE_ADAPTER_OPTIONS.map((o) => o.value).filter((v) => v !== 'custom'));
+const BE_KNOWN = new Set(BE_ADAPTER_OPTIONS.map((o) => o.value).filter((v) => v !== 'custom'));
+
+/**
+ * @param {import('@clack/prompts')} clack
+ * @param {object} opts
+ * @param {string} opts.message
+ * @param {{ value: string; label: string }[]} opts.options
+ * @param {Set<string>} opts.knownIds
+ * @param {string} [opts.customPlaceholder]
+ */
+export async function promptAdapter(clack, opts) {
+  const { select, text, isCancel, cancel } = clack;
+  const choice = await select({
+    message: opts.message,
+    options: opts.options,
+  });
+  if (isCancel(choice)) {
+    cancel('Cancelled.');
+    process.exit(0);
+  }
+  if (choice !== 'custom') {
+    return choice;
+  }
+  const customAns = await text({
+    message: 'Custom adapter id (must match adapters/<id>/ in FlowGrid):',
+    placeholder: opts.customPlaceholder ?? 'custom',
+  });
+  if (isCancel(customAns)) {
+    cancel('Cancelled.');
+    process.exit(0);
+  }
+  const id = (customAns || opts.customPlaceholder || 'custom').trim();
+  if (!opts.knownIds.has(id) && id !== 'custom') {
+    console.log(
+      `\n  ! Adapter "${id}" is not in the standard list — codegen/harness overlay may be limited until you add adapters/${id}/.\n`,
+    );
+  }
+  return id || 'custom';
+}
+
+export async function promptFeAdapter(clack) {
+  return promptAdapter(clack, {
+    message: 'Select Frontend technology:',
+    options: FE_ADAPTER_OPTIONS,
+    knownIds: FE_KNOWN,
+    customPlaceholder: 'custom',
+  });
+}
+
+export async function promptBeAdapter(clack) {
+  return promptAdapter(clack, {
+    message: 'Select Backend technology:',
+    options: BE_ADAPTER_OPTIONS,
+    knownIds: BE_KNOWN,
+    customPlaceholder: 'custom',
+  });
+}

package/bin/lib/init-scaffold.mjs

@@ -155,4 +155,13 @@ export function applyTestsHubScaffold(opts) {
     if (!fs.existsSync(destTestsRoot)) fs.mkdirSync(destTestsRoot, { recursive: true });
     copyTreeIfMissing(testsSkeleton, destTestsRoot, copyRecursive);
   }
+
+  const harnessTestTemplates = path.join(packageRoot, 'harness', 'tests', 'templates');
+  const destHarnessTpl = path.join(destTestsRoot, '_templates');
+  if (fs.existsSync(harnessTestTemplates)) {
+    console.log(
+      pc.blue(`  + Tests-docs golden templates → ${path.relative(projectRoot, destHarnessTpl)}`),
+    );
+    copyTreeIfMissing(harnessTestTemplates, destHarnessTpl, copyRecursive);
+  }
 }

package/bin/lib/inject-consumer-scripts.mjs

@@ -0,0 +1,115 @@
+/**
+ * npm scripts injected into consumer package.json after flowgrid init.
+ * SSOT names: flowgrid:* ; aliases match docs (spec:*, cases:*).
+ */
+
+/**
+ * @param {object} pkg — package.json object (mutated)
+ * @param {object} opts
+ */
+export function injectFlowgridConsumerScripts(pkg, opts) {
+  const {
+    selectedType,
+    feDocRoot,
+    feTestRoot,
+    docsHubInRepo,
+    testsHubInRepo,
+  } = opts;
+
+  pkg.scripts = pkg.scripts || {};
+
+  const auditScripts = {
+    'flowgrid:audit': 'flowgrid audit',
+    'flowgrid:audit:spec': 'flowgrid audit spec',
+    'flowgrid:audit:flow': 'flowgrid audit flow',
+    'flowgrid:audit:api': 'flowgrid audit api',
+    'flowgrid:audit:testcase': 'flowgrid audit testcase',
+    'flowgrid:audit:fe-be': 'flowgrid audit fe-be',
+    'flowgrid:audit:scenario': 'flowgrid audit scenario',
+    'flowgrid:audit:e2e': 'flowgrid audit e2e',
+    'flowgrid:audit:legacy': 'flowgrid audit legacy',
+    'flowgrid:harness-sync': 'flowgrid harness sync',
+    'flowgrid:harness-sync:full-docs': 'flowgrid harness sync --full-docs',
+    'flowgrid:doctor': 'flowgrid doctor',
+    'flowgrid:doctor:fix': 'flowgrid doctor --fix',
+  };
+  Object.assign(pkg.scripts, auditScripts);
+
+  const injectDocsHubScripts =
+    selectedType === 'Document' || (feDocRoot && docsHubInRepo);
+  if (injectDocsHubScripts) {
+    Object.assign(pkg.scripts, {
+      'flowgrid:split': 'flowgrid split',
+      'flowgrid:split_all': 'flowgrid split_all',
+      'flowgrid:merge': 'flowgrid merge',
+      'flowgrid:check': 'flowgrid check',
+      'flowgrid:render': 'flowgrid render',
+      'flowgrid:openapi': 'flowgrid openapi_render',
+      'flowgrid:openapi-gen': 'flowgrid openapi_gen',
+      'flowgrid:api-check': 'flowgrid api:check',
+      'flowgrid:openapi-ui': 'flowgrid openapi_build_ui',
+      'flowgrid:publish': 'flowgrid publish',
+      'flow:render': 'flowgrid render',
+      'flow:publish': 'flowgrid publish',
+      'spec:split': 'flowgrid split',
+      'spec:merge': 'flowgrid merge',
+      'spec:split:check': 'flowgrid check',
+      'spec:split:all': 'flowgrid split_all',
+      'openapi:gen': 'flowgrid openapi_gen',
+      'openapi:render': 'flowgrid openapi_render',
+    });
+  }
+
+  const injectVitepressScripts =
+    selectedType === 'Document' ||
+    selectedType === 'Test' ||
+    Boolean(feDocRoot || feTestRoot);
+  if (injectVitepressScripts) {
+    pkg.scripts['flowgrid:dev'] = 'flowgrid dev';
+    pkg.scripts['flowgrid:build'] = 'flowgrid build';
+    if (injectDocsHubScripts || selectedType === 'Document') {
+      pkg.scripts['flow:dev'] = 'flowgrid dev';
+    }
+  }
+
+  if (selectedType === 'Frontend' || selectedType === 'Fullstack') {
+    Object.assign(pkg.scripts, {
+      'flowgrid:gen': 'flowgrid gen',
+      'flowgrid:unit': 'flowgrid unit-gen',
+      'flowgrid:css': 'flowgrid gen-css',
+      'flowgrid:registry-sync': 'flowgrid registry:sync',
+    });
+  }
+
+  if (selectedType === 'Backend' || selectedType === 'Fullstack') {
+    Object.assign(pkg.scripts, {
+      'flowgrid:registry-sync': 'flowgrid registry:sync',
+      'flowgrid:api-gen': 'flowgrid api-gen',
+      'flowgrid:api-unit': 'flowgrid api-unit-gen',
+      'flowgrid:openapi': 'flowgrid openapi_render',
+      'flowgrid:openapi-gen': 'flowgrid openapi_gen',
+      'flowgrid:api-check': 'flowgrid api:check',
+    });
+  }
+
+  if (selectedType === 'Frontend' || selectedType === 'Backend' || selectedType === 'Fullstack') {
+    pkg.scripts['flowgrid:contract'] = 'flowgrid contract-gen';
+  }
+
+  const injectTestsHubScripts = selectedType === 'Test' || Boolean(feTestRoot);
+  if (injectTestsHubScripts) {
+    Object.assign(pkg.scripts, {
+      'flowgrid:cases': 'flowgrid cases:render',
+      'flowgrid:cases-check': 'flowgrid cases:check',
+      'flowgrid:cases-cov': 'flowgrid cases:coverage',
+      'flowgrid:cases-gate': 'flowgrid cases:gate',
+      'flowgrid:e2e-gen': 'flowgrid testcase:gen',
+      'flowgrid:api-e2e-gen': 'flowgrid testcase:gen:api',
+      'flowgrid:e2e-reg': 'flowgrid e2e-registry',
+      'flowgrid:tests-publish': 'flowgrid tests:publish',
+      'cases:check': 'flowgrid cases:check',
+      'cases:gate': 'flowgrid cases:gate',
+      'cases:render': 'flowgrid cases:render',
+    });
+  }
+}