@ryuenn3123/agentic-senior-core 4.4.0 → 5.2.0

package/lib/cli/project-scaffolder/discovery.mjs

@@ -1,272 +0,0 @@
-import fs from 'node:fs/promises';
-
-import { askChoice, askYesNo } from '../utils.mjs';
-import {
-  ARCHITECTURE_STYLE_CHOICES,
-  DOC_INDEX_FILE_NAME,
-  DOCKER_STRATEGY_CHOICES,
-  SUPPORTED_DOC_LANGUAGES,
-} from './constants.mjs';
-
-const PROJECT_SCOPE_CHOICES = [
-  'Frontend only',
-  'Backend only',
-  'Both (frontend + backend)',
-];
-
-const AGENT_RECOMMENDATION_REQUIRED = 'Agent recommendation required from current brief, repo evidence, and live official docs';
-
-function parseBooleanLikeValue(rawValue) {
-  const normalizedValue = String(rawValue || '').trim().toLowerCase();
-  if (['true', 'yes', 'y', '1'].includes(normalizedValue)) {
-    return true;
-  }
-
-  if (['false', 'no', 'n', '0'].includes(normalizedValue)) {
-    return false;
-  }
-
-  return null;
-}
-
-function resolveDockerStrategy({ dockerStrategy, useDocker, useDockerDevelopment, useDockerProduction }) {
-  if (typeof dockerStrategy === 'string' && dockerStrategy.trim().length > 0) {
-    const normalizedDockerStrategy = dockerStrategy.trim().toLowerCase();
-    const directMatch = DOCKER_STRATEGY_CHOICES.find(
-      (dockerStrategyChoice) => dockerStrategyChoice.toLowerCase() === normalizedDockerStrategy
-    );
-
-    if (directMatch) {
-      return directMatch;
-    }
-  }
-
-  const normalizedUseDocker = typeof useDocker === 'boolean' ? useDocker : parseBooleanLikeValue(useDocker);
-  const normalizedUseDockerDevelopment = typeof useDockerDevelopment === 'boolean'
-    ? useDockerDevelopment
-    : parseBooleanLikeValue(useDockerDevelopment);
-  const normalizedUseDockerProduction = typeof useDockerProduction === 'boolean'
-    ? useDockerProduction
-    : parseBooleanLikeValue(useDockerProduction);
-
-  if (normalizedUseDocker === false) {
-    return DOCKER_STRATEGY_CHOICES[0];
-  }
-
-  if (normalizedUseDockerDevelopment === true && normalizedUseDockerProduction === true) {
-    return DOCKER_STRATEGY_CHOICES[3];
-  }
-
-  if (normalizedUseDockerDevelopment === true && normalizedUseDockerProduction !== true) {
-    return DOCKER_STRATEGY_CHOICES[1];
-  }
-
-  if (normalizedUseDockerProduction === true && normalizedUseDockerDevelopment !== true) {
-    return DOCKER_STRATEGY_CHOICES[2];
-  }
-
-  if (normalizedUseDocker === true) {
-    return DOCKER_STRATEGY_CHOICES[3];
-  }
-
-  return DOCKER_STRATEGY_CHOICES[0];
-}
-
-function resolveArchitectureStyle(rawArchitectureStyle) {
-  const normalizedArchitectureStyle = String(rawArchitectureStyle || '').trim().toLowerCase();
-
-  if (!normalizedArchitectureStyle) {
-    return AGENT_RECOMMENDATION_REQUIRED;
-  }
-
-  if (normalizedArchitectureStyle === 'monolith' || normalizedArchitectureStyle === 'modular monolith') {
-    return ARCHITECTURE_STYLE_CHOICES[0];
-  }
-
-  if (
-    normalizedArchitectureStyle === 'microservice'
-    || normalizedArchitectureStyle === 'microservices'
-    || normalizedArchitectureStyle === 'distributed'
-    || normalizedArchitectureStyle === 'distributed system'
-    || normalizedArchitectureStyle === 'microservice / distributed system'
-  ) {
-    return ARCHITECTURE_STYLE_CHOICES[1];
-  }
-
-  const directMatch = ARCHITECTURE_STYLE_CHOICES.find(
-    (architectureStyleChoice) => architectureStyleChoice.toLowerCase() === normalizedArchitectureStyle
-  );
-
-  return directMatch || ARCHITECTURE_STYLE_CHOICES[0];
-}
-
-export function normalizeDocsLanguage(rawDocsLanguage = 'en') {
-  const normalizedDocsLanguage = String(rawDocsLanguage || 'en').trim().toLowerCase();
-  return SUPPORTED_DOC_LANGUAGES.has(normalizedDocsLanguage) ? normalizedDocsLanguage : null;
-}
-
-export async function runProjectDiscovery(userInterface, options = {}) {
-  console.log('\n--- Project Setup ---');
-  console.log('I will ask the minimum needed questions, then let the AI agent recommend unresolved technical decisions from the brief, repo evidence, and live official docs.\n');
-  console.log('You can answer in your own language.');
-  console.log('CLI prompts stay in English, but non-English answers are fully supported.\n');
-
-  const defaultProjectName = (options.defaultProjectName || '').trim();
-  const defaultProjectDescription = String(options.defaultProjectDescription || '').trim();
-  const defaultIncludeCiGuardrails = typeof options.defaultIncludeCiGuardrails === 'boolean'
-    ? options.defaultIncludeCiGuardrails
-    : true;
-  const shouldAskForCiGuardrails = options.askForCiGuardrails !== false;
-
-  const projectName = defaultProjectName || 'Untitled project';
-  const briefPrompt = defaultProjectDescription
-    ? `One-line project brief (press Enter to use current brief): `
-    : 'One-line project brief (optional but recommended): ';
-  const projectBriefAnswer = (await userInterface.question(briefPrompt)).trim();
-  const projectDescription = projectBriefAnswer
-    || defaultProjectDescription
-    || 'Project brief unresolved. The AI agent must ask for or infer product context before implementation.';
-
-  const projectScope = await askChoice('Project scope:', PROJECT_SCOPE_CHOICES, userInterface);
-  const primaryDomain = projectScope === 'Frontend only'
-    ? 'Frontend/UI application'
-    : projectScope === 'Backend only'
-      ? 'Backend/API service'
-      : 'Fullstack product';
-
-  const dockerStrategy = await askChoice(
-    'Containerization strategy:',
-    DOCKER_STRATEGY_CHOICES,
-    userInterface
-  );
-
-  const includeCiGuardrails = shouldAskForCiGuardrails
-    ? await askYesNo(
-      'Enable CI/CD quality checks (guardrails) and the LLM Judge policy?',
-      userInterface,
-      defaultIncludeCiGuardrails
-    )
-    : defaultIncludeCiGuardrails;
-
-  return {
-    projectName,
-    projectDescription,
-    architectureStyle: AGENT_RECOMMENDATION_REQUIRED,
-    includeCiGuardrails,
-    primaryDomain,
-    databaseChoice: AGENT_RECOMMENDATION_REQUIRED,
-    authStrategy: AGENT_RECOMMENDATION_REQUIRED,
-    dockerStrategy,
-    features: [],
-    additionalContext: 'Fresh-project technical decisions are intentionally unresolved. The AI agent must recommend them from current context and official docs before coding.',
-  };
-}
-
-export function resolveProjectDocTargets(discoveryAnswers) {
-  const hasDatabase = !discoveryAnswers.databaseChoice.toLowerCase().startsWith('none');
-  const isApiOrWebDomain = ['API service', 'Web application'].includes(discoveryAnswers.primaryDomain)
-    || discoveryAnswers.primaryDomain.toLowerCase().includes('api')
-    || discoveryAnswers.primaryDomain.toLowerCase().includes('web')
-    || discoveryAnswers.primaryDomain.toLowerCase().includes('fullstack');
-
-  const requiredDocFileNames = [
-    DOC_INDEX_FILE_NAME,
-    'project-brief.md',
-    'architecture-decision-record.md',
-    'flow-overview.md',
-  ];
-
-  if (hasDatabase) {
-    requiredDocFileNames.push('database-schema.md');
-  }
-
-  if (isApiOrWebDomain) {
-    requiredDocFileNames.push('api-contract.md');
-  }
-
-  return { requiredDocFileNames };
-}
-
-export function buildSynthesisContext(_discoveryAnswers, initContext) {
-  const additionalStackFileNames = Array.isArray(initContext.additionalStackFileNames)
-    ? initContext.additionalStackFileNames
-    : [];
-  const additionalBlueprintFileNames = Array.isArray(initContext.additionalBlueprintFileNames)
-    ? initContext.additionalBlueprintFileNames
-    : [];
-
-  return {
-    stackFileName: initContext.stackFileName,
-    additionalStackFileNames,
-    blueprintFileName: initContext.blueprintFileName,
-    additionalBlueprintFileNames,
-    runtimeEnvironmentKey: initContext.runtimeEnvironmentKey || 'linux',
-    runtimeEnvironmentLabel: initContext.runtimeEnvironmentLabel || 'Linux',
-  };
-}
-
-export async function loadProjectConfig(configFilePath) {
-  const configContent = await fs.readFile(configFilePath, 'utf8');
-  const configLines = configContent.split(/\r?\n/);
-  const configEntries = {};
-  let currentKey = null;
-  let currentArrayValues = null;
-
-  for (const configLine of configLines) {
-    const trimmedLine = configLine.trim();
-
-    if (!trimmedLine || trimmedLine.startsWith('#')) {
-      continue;
-    }
-
-    if (trimmedLine.startsWith('- ') && currentKey && currentArrayValues !== null) {
-      currentArrayValues.push(trimmedLine.slice(2).trim());
-      continue;
-    }
-
-    if (currentKey && currentArrayValues !== null) {
-      configEntries[currentKey] = currentArrayValues;
-      currentKey = null;
-      currentArrayValues = null;
-    }
-
-    const colonIndex = trimmedLine.indexOf(':');
-    if (colonIndex === -1) {
-      continue;
-    }
-
-    const entryKey = trimmedLine.slice(0, colonIndex).trim();
-    const entryValue = trimmedLine.slice(colonIndex + 1).trim();
-
-    if (!entryValue) {
-      currentKey = entryKey;
-      currentArrayValues = [];
-      continue;
-    }
-
-    configEntries[entryKey] = entryValue;
-  }
-
-  if (currentKey && currentArrayValues !== null) {
-    configEntries[currentKey] = currentArrayValues;
-  }
-
-  return {
-    projectName: configEntries.projectName || configEntries.name || '',
-    projectDescription: configEntries.projectDescription || configEntries.description || '',
-    architectureStyle: resolveArchitectureStyle(configEntries.architectureStyle || configEntries.topology || configEntries.serviceTopology),
-    includeCiGuardrails: parseBooleanLikeValue(configEntries.includeCiGuardrails) ?? parseBooleanLikeValue(configEntries.ci) ?? true,
-    primaryDomain: configEntries.primaryDomain || configEntries.domain || AGENT_RECOMMENDATION_REQUIRED,
-    databaseChoice: configEntries.databaseChoice || configEntries.database || AGENT_RECOMMENDATION_REQUIRED,
-    authStrategy: configEntries.authStrategy || configEntries.auth || AGENT_RECOMMENDATION_REQUIRED,
-    dockerStrategy: resolveDockerStrategy({
-      dockerStrategy: configEntries.dockerStrategy || configEntries.containerStrategy,
-      useDocker: configEntries.useDocker,
-      useDockerDevelopment: configEntries.useDockerDevelopment || configEntries.dockerDevelopment,
-      useDockerProduction: configEntries.useDockerProduction || configEntries.dockerProduction,
-    }),
-    features: Array.isArray(configEntries.features) ? configEntries.features : [],
-    additionalContext: configEntries.additionalContext || configEntries.context || 'No additional context provided.',
-    docsLang: configEntries.docsLang || configEntries.docsLanguage || 'en',
-  };
-}

package/lib/cli/project-scaffolder/prompt-builders.mjs

@@ -1,171 +0,0 @@
-import { toTitleCase } from '../utils.mjs';
-import {
-  PROJECT_DOC_SYNTHESIS_PROMPT_VERSION,
-} from './constants.mjs';
-
-function buildDockerStrategyExecutionBlock(dockerStrategy) {
-  const selectedDockerStrategy = String(dockerStrategy || '').trim();
-  const normalizedDockerStrategy = selectedDockerStrategy.toLowerCase();
-
-  if (!selectedDockerStrategy || normalizedDockerStrategy.startsWith('no docker')) {
-    return [
-      '## Docker Execution Gate',
-      'Docker was not selected. Do not create container assets unless the user changes scope.',
-    ];
-  }
-
-  const requiredAssetFloor = [
-    '.dockerignore',
-    normalizedDockerStrategy.includes('development') || normalizedDockerStrategy.includes('both') ? 'compose.yaml for development' : null,
-    normalizedDockerStrategy.includes('production') || normalizedDockerStrategy.includes('both') ? 'compose.prod.yaml or a documented production Compose override' : null,
-    'Dockerfile stage(s) derived from the actual stack',
-    'docs/docker-runtime.md or a deployment runbook with ports, entrypoints, health checks, and source URLs',
-  ].filter(Boolean).join(', ');
-
-  return [
-    '## Docker Execution Gate',
-    `Selected Docker strategy: ${selectedDockerStrategy}`,
-    '- Load .agent-context/rules/docker-runtime.md and verify current official Docker docs before authoring assets.',
-    '- Materialize Docker assets from the actual stack; do not stop at docs-only acknowledgement or runtime notes.',
-    '- Required asset floor: ' + requiredAssetFloor + '.',
-    '- Keep development and production lanes separate when both are selected.',
-    '- If the user asks to create files without commands, write the files and documented commands, but do not execute Docker build, Compose, or registry commands.',
-    '- If Docker is enabled for development, local development setup and first-build instructions in the README must use Docker (e.g., `docker compose up`) rather than fallback local commands like `npm run dev`.',
-  ];
-}
-
-export function buildProjectContextBootstrapPrompt({
-  discoveryAnswers,
-  initContext,
-  expectedDocFileNames,
-  docsLanguage,
-}) {
-  const featuresList = Array.isArray(discoveryAnswers.features) && discoveryAnswers.features.length > 0
-    ? discoveryAnswers.features.map((feature, featureIndex) => `${featureIndex + 1}. ${feature}`).join('\n')
-    : 'Derive the first concrete feature set from the project name, description, and domain. Do not invent arbitrary modules just to fill space.';
-
-  const expectedDocsList = [
-    'README.md',
-    ...expectedDocFileNames.map((fileName) => `docs/${fileName}`),
-  ]
-    .map((filePath, fileIndex) => `${fileIndex + 1}. ${filePath}`)
-    .join('\n');
-
-  return [
-    '# Bootstrap Prompt: Dynamic Project Context Synthesis',
-    '',
-    `Protocol version: ${PROJECT_DOC_SYNTHESIS_PROMPT_VERSION}`,
-    '',
-    'You are a Lead Solution Architect and Principal Engineer.',
-    'Write project context docs from scratch (no template rendering, no placeholder boilerplate).',
-    '',
-    '## Mission',
-    `Create or update these files in ${docsLanguage.toUpperCase()} language:`,
-    expectedDocsList,
-    '',
-    '## Hard Rules',
-    '1. No copy-paste from external prose.',
-    '2. Every major section must explain rationale, constraints, and required action.',
-    '3. Keep database, auth, runtime, and architecture aligned with explicit project constraints below unless user requests migration.',
-    '4. Output must be implementation-ready for engineers, not generic textbook explanation.',
-    '5. For any ecosystem or technology claim, perform live web research and include citation metadata (source + fetchedAt timestamp) rather than relying on offline heuristics.',
-    '6. Write for native English speakers at an 8th-grade reading level. Use clear, direct, plain language.',
-    '7. Avoid emoji, AI cliches, buzzwords, academic phrasing, padding, and generic filler.',
-    '8. Separate confirmed facts from assumptions explicitly. When context is incomplete, add an `Assumptions to Validate` section and a `Next Validation Action` line.',
-    '9. If user inputs conflict with repo evidence, call out the conflict and choose the safer interpretation instead of silently forcing a generic answer.',
-    '10. Do not invent modules or architecture layers only to make the docs look complete.',
-    '11. If runtime or framework setup is unresolved, recommend the latest stable compatible option from the brief, constraints, and live official documentation before coding. If an official setup flow yields newer, better-supported defaults than manual package assembly, use that path after approval.',
-    '12. Treat topology as an agent decision unless the user explicitly constrained it. If monolith fits, explain why. If a service split fits, document the evidence and service boundary logic.',
-    '13. Required docs coverage must include a public and developer README entrypoint, feature plan, architecture rationale, flow, public API or integration contracts when relevant, data model when relevant, UI/design when relevant, security assumptions, testing strategy, runtime/deployment notes, and next validation actions.',
-    '14. Use Mermaid.js as the default diagram format for flow, sequence, ER, architecture, C4, and state diagrams embedded in Markdown docs. Do not use PlantUML, ASCII art diagrams, Graphviz DOT, or Structurizr DSL. When updating existing docs that contain prose-only descriptions, convert relevant sections to Mermaid diagrams in the same change.',
-    '15. README.md must be public and developer friendly, including for private projects: what it is, who it is for, setup, core workflow, configuration, and links to deeper docs. Do not include secrets, internal agent notes, private reasoning, or governance policy dumps.',
-    '16. docs/doc-index.md is the low-token routing map for docs/*. Keep it short, list each active doc, and explain when an agent should read it. Do not make it the source of truth for requirements or architecture.',
-    '17. Keep docs complete but compact. Add extra docs files only for stable, distinct, or long workflows such as hardware setup, deployment, operations, testing validation, or troubleshooting.',
-    '18. Add SRS, PRD, technical-design, or ERD docs only when project evidence triggers them. Use PRD for product-roadmap/user-story ownership, SRS for contractual or multi-stakeholder acceptance criteria, technical-design for non-trivial architecture decisions, and ERD only as a separate file when the schema is too complex for docs/database-schema.md.',
-    '',
-    '## Project Inputs',
-    `- Project name: ${discoveryAnswers.projectName}`,
-    `- Project description: ${discoveryAnswers.projectDescription}`,
-    `- Project topology decision: ${discoveryAnswers.architectureStyle}`,
-    `- Primary domain: ${discoveryAnswers.primaryDomain}`,
-    `- Database strategy: ${discoveryAnswers.databaseChoice}`,
-    `- Auth strategy: ${discoveryAnswers.authStrategy}`,
-    `- Docker strategy: ${discoveryAnswers.dockerStrategy}`,
-    `- Runtime environment: ${initContext.runtimeEnvironmentLabel || initContext.runtimeEnvironmentKey || 'Linux'}`,
-    `- Runtime constraint: ${initContext.stackFileName === 'agent-decision-runtime.md' ? 'agent recommendation required before coding' : toTitleCase(initContext.stackFileName)}`,
-    `- Architecture constraint: ${initContext.blueprintFileName === 'agent-decision-architecture.md' ? 'agent recommendation required before coding' : toTitleCase(initContext.blueprintFileName)}`,
-    `- Additional runtime constraints: ${Array.isArray(initContext.additionalStackFileNames) && initContext.additionalStackFileNames.length > 0 ? initContext.additionalStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ') : 'none'}`,
-    `- Additional architecture constraints: ${Array.isArray(initContext.additionalBlueprintFileNames) && initContext.additionalBlueprintFileNames.length > 0 ? initContext.additionalBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName)).join(', ') : 'none'}`,
-    '',
-    ...buildDockerStrategyExecutionBlock(discoveryAnswers.dockerStrategy),
-    '',
-    '## Key Features',
-    featuresList,
-    '',
-    '## Additional Context',
-    discoveryAnswers.additionalContext || 'No additional context provided.',
-    '',
-    '## Required Execution',
-    '1. Create all required docs files listed above with complete Markdown content.',
-    '2. Make the docs adaptive to the real repo and prompt context. These are living references, not frozen templates.',
-    '3. In docs/doc-index.md, include a compact table with document path, purpose, reads-when triggers, status, and last-updated date.',
-    '4. In docs/project-brief.md and docs/architecture-decision-record.md, include explicit sections for confirmed facts, assumptions to validate, and next validation actions whenever context is incomplete.',
-    '5. Before implementation, use README.md plus docs/doc-index.md to select only the relevant docs for the current task instead of broad-reading docs/*.md.',
-    '6. Before implementation, use the docs to confirm stack, runtime, architecture, public contracts, data, validation, and delivery assumptions.',
-    '7. Keep content original, specific to this project, and actionable for implementation.',
-    '8. After writing docs, continue coding tasks using these docs as living project context.',
-    '',
-  ].join('\n');
-}
-
-export function buildDesignBootstrapPrompt({
-  discoveryAnswers,
-  initContext,
-  docsLanguage,
-}) {
-
-  return [
-    '# Bootstrap Prompt: Dynamic Design Contract Synthesis',
-    '',
-    `Protocol version: ${PROJECT_DOC_SYNTHESIS_PROMPT_VERSION}`,
-    '',
-    'You are the Lead UI/UX Art Director for this project.',
-    'Create a compact design token file, not a fixed stylistic template or prose document.',
-    '',
-    '## Mission',
-    `Author docs/DESIGN.md in ${docsLanguage.toUpperCase()} language as a compact token file under 400 tokens.`,
-    '',
-    '## Deliverables',
-    '1. docs/DESIGN.md (compact token file)',
-    '',
-    '## Design Direction Process',
-    'Follow `.agent-context/prompts/bootstrap-design.md` for the three-step design direction:',
-    '1. Name your defaults (three temptations and why each flattens this product)',
-    '2. Choose a concrete anchor (googleable, specific, not a generic quality word)',
-    '3. Record creative commitments (typography, palette, motion, composition)',
-    '',
-    '## Hard Rules',
-    '1. Do not copy external style guides or anchor to famous product surfaces.',
-    '2. Use repo evidence, active brief, current docs, and current official docs for technology choices.',
-    '3. WCAG 2.2 AA is the hard floor. APCA is advisory perceptual tuning only.',
-    '4. Research current official docs before importing any new UI-related library.',
-    '5. Do not default to any component kit by habit, and do not avoid them when they fit.',
-    '6. Keep research vocabulary internal; evidence, anchor, and category-code labels must not appear in public-facing docs.',
-    '7. Treat production content as blocking: remove demo, placeholder, lorem, TODO, and scaffold copy.',
-    '',
-    '## Project Inputs',
-    `- Project name: ${discoveryAnswers.projectName}`,
-    `- Product context: ${discoveryAnswers.projectDescription}`,
-    `- Project topology decision: ${discoveryAnswers.architectureStyle}`,
-    `- Domain: ${discoveryAnswers.primaryDomain}`,
-    `- Runtime constraint: ${initContext.stackFileName === 'agent-decision-runtime.md' ? 'agent recommendation required before coding' : toTitleCase(initContext.stackFileName)}`,
-    `- Architecture constraint: ${initContext.blueprintFileName === 'agent-decision-architecture.md' ? 'agent recommendation required before coding' : toTitleCase(initContext.blueprintFileName)}`,
-    '',
-    '## Required Execution',
-    '1. Follow the output format defined in `.agent-context/prompts/bootstrap-design.md`: Anchor, Tokens, Constraints, Previous Directions.',
-    '2. Keep docs/DESIGN.md under 400 tokens. Rationale and derivation stay in working memory.',
-    '3. Make the token file executable without screenshot dependency.',
-    '4. After the token file exists, use it as a first-class source for future UI tasks.',
-    '',
-  ].join('\n');
-}

package/lib/cli/project-scaffolder/storage.mjs

@@ -1,144 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import { ensureDirectory, pathExists } from '../utils.mjs';
-import {
-  PROJECT_DOC_FILE_NAMES,
-  PROJECT_DOC_SYNTHESIS_PROMPT_VERSION,
-  PROJECT_DOC_TEMPLATE_VERSION,
-  UI_DESIGN_CONTRACT_FILE_NAMES,
-} from './constants.mjs';
-import {
-  buildSynthesisContext,
-  normalizeDocsLanguage,
-  resolveProjectDocTargets,
-} from './discovery.mjs';
-import {
-  shouldBootstrapDesignDocument,
-} from './ui-scope-detection.mjs';
-import {
-  buildDesignBootstrapPrompt,
-  buildProjectContextBootstrapPrompt,
-} from './prompt-builders.mjs';
-
-export async function generateProjectDocumentation(
-  targetDirectoryPath,
-  discoveryAnswers,
-  initContext,
-  options = {}
-) {
-  const normalizedDocsLanguage = normalizeDocsLanguage(options.docsLanguage || 'en');
-  if (!normalizedDocsLanguage) {
-    throw new Error(`Unsupported docs language: ${options.docsLanguage}. Supported values: en, id`);
-  }
-
-  const docsDirectoryPath = path.join(targetDirectoryPath, 'docs');
-  const promptsDirectoryPath = path.join(targetDirectoryPath, '.agent-context', 'prompts');
-  await ensureDirectory(docsDirectoryPath);
-  await ensureDirectory(promptsDirectoryPath);
-
-  const synthesisContext = buildSynthesisContext(discoveryAnswers, initContext);
-  const { requiredDocFileNames } = resolveProjectDocTargets(discoveryAnswers);
-  const expectedDocFileNames = [...requiredDocFileNames];
-  const generatedPromptFileNames = [];
-  const materializedFileNames = [];
-  const shouldCreateDesignContract = shouldBootstrapDesignDocument(discoveryAnswers, initContext);
-
-  if (shouldCreateDesignContract) {
-    for (const designContractFileName of UI_DESIGN_CONTRACT_FILE_NAMES) {
-      if (!expectedDocFileNames.includes(designContractFileName)) {
-        expectedDocFileNames.push(designContractFileName);
-      }
-    }
-  }
-
-  const projectContextPromptFileName = 'bootstrap-project-context.md';
-  const projectContextPromptContent = buildProjectContextBootstrapPrompt({
-    discoveryAnswers,
-    initContext: synthesisContext,
-    expectedDocFileNames,
-    docsLanguage: normalizedDocsLanguage,
-  });
-  await fs.writeFile(
-    path.join(promptsDirectoryPath, projectContextPromptFileName),
-    projectContextPromptContent,
-    'utf8'
-  );
-  generatedPromptFileNames.push(projectContextPromptFileName);
-
-  if (shouldCreateDesignContract) {
-    const designPromptFileName = 'bootstrap-design.md';
-    const designPromptContent = buildDesignBootstrapPrompt({
-      discoveryAnswers,
-      initContext: synthesisContext,
-      docsLanguage: normalizedDocsLanguage,
-    });
-    await fs.writeFile(path.join(promptsDirectoryPath, designPromptFileName), designPromptContent, 'utf8');
-    generatedPromptFileNames.push(designPromptFileName);
-  }
-
-  return {
-    docsDirectoryPath,
-    generatedFileNames: expectedDocFileNames,
-    generatedPromptFileNames,
-    materializedFileNames,
-    bootstrapMode: 'ai-synthesis',
-    synthesisPromptVersion: PROJECT_DOC_SYNTHESIS_PROMPT_VERSION,
-    templateVersion: PROJECT_DOC_TEMPLATE_VERSION,
-    docsLanguage: normalizedDocsLanguage,
-    discoveryAnswers,
-  };
-}
-
-export async function isDirectoryEffectivelyEmpty(targetDirectoryPath) {
-  try {
-    const directoryEntries = await fs.readdir(targetDirectoryPath);
-    const meaningfulEntries = directoryEntries.filter(
-      (entryName) => entryName !== '.git' && entryName !== '.gitignore'
-    );
-    return meaningfulEntries.length === 0;
-  } catch {
-    return true;
-  }
-}
-
-export async function hasExistingProjectDocs(targetDirectoryPath) {
-  const projectBriefPath = path.join(targetDirectoryPath, 'docs', 'project-brief.md');
-  return pathExists(projectBriefPath);
-}
-
-function extractTemplateVersion(documentContent) {
-  const templateVersionMatch = documentContent.match(/^(?:Template version|Versi template):\s*(.+)$/im);
-  return templateVersionMatch ? templateVersionMatch[1].trim() : null;
-}
-
-export async function detectProjectDocTemplateStaleness(targetDirectoryPath) {
-  const docsDirectoryPath = path.join(targetDirectoryPath, 'docs');
-  const checkedFileNames = [];
-  const staleFiles = [];
-
-  for (const projectDocFileName of PROJECT_DOC_FILE_NAMES) {
-    const projectDocFilePath = path.join(docsDirectoryPath, projectDocFileName);
-    if (!(await pathExists(projectDocFilePath))) {
-      continue;
-    }
-
-    checkedFileNames.push(projectDocFileName);
-    const projectDocContent = await fs.readFile(projectDocFilePath, 'utf8');
-    const detectedTemplateVersion = extractTemplateVersion(projectDocContent);
-
-    if (!detectedTemplateVersion || detectedTemplateVersion !== PROJECT_DOC_TEMPLATE_VERSION) {
-      staleFiles.push({
-        fileName: projectDocFileName,
-        detectedTemplateVersion,
-      });
-    }
-  }
-
-  return {
-    hasProjectDocs: checkedFileNames.length > 0,
-    expectedTemplateVersion: PROJECT_DOC_TEMPLATE_VERSION,
-    checkedFileNames,
-    staleFiles,
-  };
-}

package/lib/cli/project-scaffolder/ui-scope-detection.mjs

@@ -1,36 +0,0 @@
-/**
- * UI scope detection utility. Determines whether a project needs
- * design bootstrap based on domain and blueprint signals.
- *
- * Extracted from design-contract/seed-signals.mjs so the design
- * contract module can be removed without breaking this dependency.
- */
-
-export function shouldBootstrapDesignDocument(discoveryAnswers, initContext) {
-  const normalizedDomain = String(discoveryAnswers.primaryDomain || '').trim().toLowerCase();
-  const normalizedBlueprint = String(initContext.blueprintFileName || '').trim().toLowerCase();
-
-  const isUiDomain = normalizedDomain.includes('web')
-    || normalizedDomain.includes('mobile')
-    || normalizedDomain.includes('frontend')
-    || normalizedDomain.includes('fullstack')
-    || normalizedDomain.includes('ui');
-
-  const isBackendOnlyDomain = normalizedDomain.includes('api service')
-    || normalizedDomain.includes('cli tool')
-    || normalizedDomain.includes('library');
-
-  const blueprintLooksUi = normalizedBlueprint.includes('frontend')
-    || normalizedBlueprint.includes('landing')
-    || normalizedBlueprint.includes('ui');
-
-  if (isUiDomain) {
-    return true;
-  }
-
-  if (!isBackendOnlyDomain && blueprintLooksUi) {
-    return true;
-  }
-
-  return false;
-}

package/lib/cli/project-scaffolder.mjs

@@ -1,29 +0,0 @@
-/**
- * Project scaffolder public surface.
- *
- * The implementation is grouped by function under `lib/cli/project-scaffolder/`
- * so discovery, design-contract logic, prompt building, and persistence do not
- * collapse into one oversized module.
- */
-
-export {
-  PROJECT_DOC_TEMPLATE_VERSION,
-  PROJECT_DOC_SYNTHESIS_PROMPT_VERSION,
-} from './project-scaffolder/constants.mjs';
-
-export {
-  normalizeDocsLanguage,
-  runProjectDiscovery,
-  loadProjectConfig,
-} from './project-scaffolder/discovery.mjs';
-
-export {
-  shouldBootstrapDesignDocument,
-} from './project-scaffolder/ui-scope-detection.mjs';
-
-export {
-  generateProjectDocumentation,
-  isDirectoryEffectivelyEmpty,
-  hasExistingProjectDocs,
-  detectProjectDocTemplateStaleness,
-} from './project-scaffolder/storage.mjs';