@ryuenn3123/agentic-senior-core 4.3.15 → 5.1.0

package/lib/cli/detector/ui-signals.mjs

@@ -1,150 +0,0 @@
-/**
- * UI scope detection: combines marker sets, package.json dependencies, nested
- * workspace evidence, and explicit user scope keys to decide whether the
- * current target directory is a UI surface. Triggers the lightweight design
- * evidence scan when the answer is yes.
- */
-
-import { collectFrontendDesignEvidence } from './design-evidence.mjs';
-import { DIRECT_UI_MARKER_NAMES } from './constants.mjs';
-import { collectNestedWorkspaceProjects, collectProjectMarkers, readPackageJsonIfExists } from './workspace-scan.mjs';
-
-const UI_DEPENDENCY_NAMES = ['next', 'react', 'react-dom', 'react-native', 'expo', 'tailwindcss'];
-
-function analyzeUiSignalsForMarkerSet(markerNames, packageManifest, sourceLabel = null) {
-  const detectedUiMarkers = DIRECT_UI_MARKER_NAMES.filter((markerName) => markerNames.has(markerName));
-  const dependencySource = {
-    ...(packageManifest?.dependencies || {}),
-    ...(packageManifest?.devDependencies || {}),
-  };
-  const detectedUiDependencies = UI_DEPENDENCY_NAMES.filter((dependencyName) => dependencySource[dependencyName]);
-  const hasStrongUiMarker = detectedUiMarkers.some((markerName) => (
-    markerName.startsWith('next.config')
-    || markerName === 'react-native.config.js'
-    || markerName === 'android'
-    || markerName === 'ios'
-  ));
-  const hasUiDependencies = detectedUiDependencies.length > 0;
-  const hasStructuralUiMarkers = detectedUiMarkers.length >= 2;
-  const signalReasons = [];
-  const sourcePrefix = sourceLabel ? `${sourceLabel}: ` : '';
-
-  if (detectedUiMarkers.length > 0) {
-    signalReasons.push(`${sourcePrefix}ui markers: ${detectedUiMarkers.join(', ')}`);
-  }
-
-  if (detectedUiDependencies.length > 0) {
-    signalReasons.push(`${sourcePrefix}ui dependencies: ${detectedUiDependencies.join(', ')}`);
-  }
-
-  return {
-    signalReasons,
-    detectedUiMarkers,
-    detectedUiDependencies,
-    hasStrongUiMarker,
-    hasUiDependencies,
-    hasStructuralUiMarkers,
-  };
-}
-
-export async function detectUiScopeSignals({
-  targetDirectoryPath,
-  selectedStackFileName,
-  selectedBlueprintFileName,
-  packageManifest = null,
-  projectScopeKey = null,
-  projectScopeSourceLabel = 'project scope',
-}) {
-  const signalReasons = [];
-  const markerNames = await collectProjectMarkers(targetDirectoryPath);
-  const resolvedPackageManifest = packageManifest || await readPackageJsonIfExists(targetDirectoryPath);
-  const nestedWorkspaceProjects = await collectNestedWorkspaceProjects(targetDirectoryPath);
-
-  const normalizedProjectScopeKey = String(projectScopeKey || '').trim().toLowerCase();
-  if (normalizedProjectScopeKey === 'frontend-only' || normalizedProjectScopeKey === 'both') {
-    signalReasons.push(`${projectScopeSourceLabel}: ${normalizedProjectScopeKey}`);
-  }
-
-  const selectedStackKey = String(selectedStackFileName || '').trim().toLowerCase();
-  if (selectedStackKey === 'react-native.md' || selectedStackKey === 'flutter.md') {
-    signalReasons.push(`selected stack implies UI runtime: ${selectedStackKey}`);
-  }
-
-  const selectedBlueprintKey = String(selectedBlueprintFileName || '').trim().toLowerCase();
-  if (selectedBlueprintKey.includes('frontend') || selectedBlueprintKey.includes('landing') || selectedBlueprintKey.includes('mobile-app')) {
-    signalReasons.push(`selected blueprint implies UI scope: ${selectedBlueprintKey}`);
-  }
-
-  const rootUiSignals = analyzeUiSignalsForMarkerSet(markerNames, resolvedPackageManifest);
-  signalReasons.push(...rootUiSignals.signalReasons);
-
-  const nestedUiSignals = nestedWorkspaceProjects
-    .map((nestedWorkspaceProject) => ({
-      ...nestedWorkspaceProject,
-      ...analyzeUiSignalsForMarkerSet(
-        nestedWorkspaceProject.markerNames,
-        nestedWorkspaceProject.packageManifest,
-        `workspace ${nestedWorkspaceProject.relativePath}`,
-      ),
-    }))
-    .filter((nestedWorkspaceProject) => nestedWorkspaceProject.signalReasons.length > 0);
-
-  for (const nestedUiSignal of nestedUiSignals) {
-    signalReasons.push(...nestedUiSignal.signalReasons);
-  }
-
-  const detectedUiMarkers = Array.from(new Set([
-    ...rootUiSignals.detectedUiMarkers,
-    ...nestedUiSignals.flatMap((nestedUiSignal) => nestedUiSignal.detectedUiMarkers),
-  ]));
-  const detectedUiDependencies = Array.from(new Set([
-    ...rootUiSignals.detectedUiDependencies,
-    ...nestedUiSignals.flatMap((nestedUiSignal) => nestedUiSignal.detectedUiDependencies),
-  ]));
-
-  const hasStrongUiMarker = rootUiSignals.hasStrongUiMarker
-    || nestedUiSignals.some((nestedUiSignal) => nestedUiSignal.hasStrongUiMarker);
-  const hasUiDependencies = rootUiSignals.hasUiDependencies
-    || nestedUiSignals.some((nestedUiSignal) => nestedUiSignal.hasUiDependencies);
-  const hasStructuralUiMarkers = rootUiSignals.hasStructuralUiMarkers
-    || nestedUiSignals.some((nestedUiSignal) => nestedUiSignal.hasStructuralUiMarkers);
-  const isUiScopeLikely = signalReasons.length > 0
-    && (hasStrongUiMarker || hasUiDependencies || hasStructuralUiMarkers || normalizedProjectScopeKey.length > 0);
-  const preferredUiWorkspaceEntry = nestedUiSignals.find((nestedUiSignal) => (
-    nestedUiSignal.hasStrongUiMarker
-    || nestedUiSignal.hasUiDependencies
-    || nestedUiSignal.hasStructuralUiMarkers
-  )) || null;
-  const frontendScanRootDirectoryPaths = (
-    !rootUiSignals.hasStrongUiMarker
-    && !rootUiSignals.hasUiDependencies
-    && !rootUiSignals.hasStructuralUiMarkers
-    && nestedUiSignals.length > 0
-  )
-    ? nestedUiSignals.map((nestedUiSignal) => nestedUiSignal.directoryPath)
-    : [];
-  const designEvidence = isUiScopeLikely
-    ? await collectFrontendDesignEvidence({
-      targetDirectoryPath,
-      markerNames,
-      scanRootDirectoryPaths: frontendScanRootDirectoryPaths,
-    })
-    : null;
-  const frontendEvidenceMetrics = designEvidence?.frontendEvidenceMetrics || null;
-  const designEvidenceSummary = designEvidence?.designEvidenceSummary || null;
-
-  return {
-    isUiScopeLikely,
-    signalReasons,
-    detectedUiMarkers,
-    detectedUiDependencies,
-    frontendEvidenceMetrics,
-    designEvidenceSummary,
-    packageManifest: preferredUiWorkspaceEntry?.packageManifest || resolvedPackageManifest,
-    workspaceUiEntries: nestedUiSignals.map((nestedUiSignal) => ({
-      relativePath: nestedUiSignal.relativePath,
-      detectedUiMarkers: nestedUiSignal.detectedUiMarkers,
-      detectedUiDependencies: nestedUiSignal.detectedUiDependencies,
-    })),
-  };
-}

package/lib/cli/detector/workspace-scan.mjs

@@ -1,177 +0,0 @@
-/**
- * Workspace traversal: from a target directory, find immediate project markers,
- * locate nested project candidates inside monorepo containers, and read package
- * manifests when present. The scan is bounded by max depth and a per-run
- * directory budget so it terminates cleanly on huge repos.
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import {
-  hasProjectMarkers,
-  INTERNAL_GOVERNANCE_SURFACE_NAMES,
-  looksLikeWorkspaceSearchCandidate,
-  WORKSPACE_CONTAINER_DIRECTORY_NAMES,
-  WORKSPACE_ROOT_MARKER_FILE_NAMES,
-  WORKSPACE_SCAN_IGNORE_DIRECTORY_NAMES,
-  WORKSPACE_SCAN_MAX_DEPTH,
-  WORKSPACE_SCAN_MAX_DIRECTORIES,
-} from './constants.mjs';
-
-export async function collectProjectMarkers(targetDirectoryPath) {
-  const markerNames = new Set();
-  const directoryEntries = await fs.readdir(targetDirectoryPath, { withFileTypes: true });
-
-  for (const directoryEntry of directoryEntries) {
-    if (directoryEntry.name === '.git' || directoryEntry.name === 'node_modules') {
-      continue;
-    }
-
-    if (INTERNAL_GOVERNANCE_SURFACE_NAMES.has(directoryEntry.name)) {
-      continue;
-    }
-
-    markerNames.add(directoryEntry.name);
-  }
-
-  return markerNames;
-}
-
-export async function readPackageJsonIfExists(targetDirectoryPath) {
-  const packageJsonPath = path.join(targetDirectoryPath, 'package.json');
-
-  try {
-    const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
-    return JSON.parse(packageJsonContent);
-  } catch {
-    return null;
-  }
-}
-
-async function readDirectoryEntries(directoryPath) {
-  try {
-    return await fs.readdir(directoryPath, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-
-export async function collectNestedWorkspaceProjects(targetDirectoryPath) {
-  const rootDirectoryEntries = await readDirectoryEntries(targetDirectoryPath);
-  const rootMarkerNames = new Set(rootDirectoryEntries.map((directoryEntry) => directoryEntry.name));
-  const rootLooksLikeWorkspace = Array.from(rootMarkerNames).some((markerName) => (
-    WORKSPACE_ROOT_MARKER_FILE_NAMES.has(markerName)
-    || looksLikeWorkspaceSearchCandidate(markerName)
-  ));
-  const nestedWorkspaceProjects = [];
-  const queuedWorkspacePaths = new Set();
-  const workspaceQueue = [];
-  let scannedDirectoryCount = 0;
-
-  for (const rootDirectoryEntry of rootDirectoryEntries) {
-    if (!rootDirectoryEntry.isDirectory()) {
-      continue;
-    }
-
-    if (WORKSPACE_SCAN_IGNORE_DIRECTORY_NAMES.has(rootDirectoryEntry.name)) {
-      continue;
-    }
-
-    const shouldInspectRootChild = rootLooksLikeWorkspace
-      || looksLikeWorkspaceSearchCandidate(rootDirectoryEntry.name);
-
-    if (!shouldInspectRootChild) {
-      continue;
-    }
-
-    const rootChildDirectoryPath = path.join(targetDirectoryPath, rootDirectoryEntry.name);
-    const rootChildEntries = await readDirectoryEntries(rootChildDirectoryPath);
-    const rootChildMarkerNames = new Set(rootChildEntries.map((directoryEntry) => directoryEntry.name));
-    const rootChildRelativePath = rootDirectoryEntry.name.replace(/\\/g, '/');
-
-    workspaceQueue.push({
-      directoryPath: rootChildDirectoryPath,
-      relativePath: rootChildRelativePath,
-      markerNames: rootChildMarkerNames,
-      depth: 1,
-      underWorkspaceContainer: WORKSPACE_CONTAINER_DIRECTORY_NAMES.has(rootDirectoryEntry.name.toLowerCase()),
-    });
-    queuedWorkspacePaths.add(rootChildRelativePath);
-  }
-
-  while (workspaceQueue.length > 0 && scannedDirectoryCount < WORKSPACE_SCAN_MAX_DIRECTORIES) {
-    const currentWorkspaceEntry = workspaceQueue.shift();
-    scannedDirectoryCount += 1;
-
-    const isProjectCandidate = hasProjectMarkers(currentWorkspaceEntry.markerNames);
-    const currentDirectoryName = path.basename(currentWorkspaceEntry.directoryPath).toLowerCase();
-    const isWorkspaceContainer = WORKSPACE_CONTAINER_DIRECTORY_NAMES.has(currentDirectoryName);
-
-    if (isProjectCandidate) {
-      nestedWorkspaceProjects.push({
-        directoryPath: currentWorkspaceEntry.directoryPath,
-        relativePath: currentWorkspaceEntry.relativePath,
-        markerNames: currentWorkspaceEntry.markerNames,
-        packageManifest: currentWorkspaceEntry.markerNames.has('package.json')
-          ? await readPackageJsonIfExists(currentWorkspaceEntry.directoryPath)
-          : null,
-      });
-    }
-
-    if (currentWorkspaceEntry.depth >= WORKSPACE_SCAN_MAX_DEPTH) {
-      continue;
-    }
-
-    const shouldTraverseChildren = currentWorkspaceEntry.underWorkspaceContainer
-      || isWorkspaceContainer
-      || !isProjectCandidate;
-
-    if (!shouldTraverseChildren) {
-      continue;
-    }
-
-    const childEntries = await readDirectoryEntries(currentWorkspaceEntry.directoryPath);
-    for (const childEntry of childEntries) {
-      if (!childEntry.isDirectory()) {
-        continue;
-      }
-
-      if (WORKSPACE_SCAN_IGNORE_DIRECTORY_NAMES.has(childEntry.name)) {
-        continue;
-      }
-
-      const childLooksRelevant = looksLikeWorkspaceSearchCandidate(childEntry.name);
-      if (!childLooksRelevant && !currentWorkspaceEntry.underWorkspaceContainer && !isWorkspaceContainer) {
-        continue;
-      }
-
-      const childDirectoryPath = path.join(currentWorkspaceEntry.directoryPath, childEntry.name);
-      const childRelativePath = path.join(currentWorkspaceEntry.relativePath, childEntry.name).replace(/\\/g, '/');
-
-      if (queuedWorkspacePaths.has(childRelativePath)) {
-        continue;
-      }
-
-      const childDirectoryEntries = await readDirectoryEntries(childDirectoryPath);
-      const childMarkerNames = new Set(childDirectoryEntries.map((directoryEntry) => directoryEntry.name));
-      const childIsProjectCandidate = hasProjectMarkers(childMarkerNames);
-      const childIsWorkspaceContainer = WORKSPACE_CONTAINER_DIRECTORY_NAMES.has(childEntry.name.toLowerCase());
-
-      if (!childIsProjectCandidate && !childIsWorkspaceContainer && !childLooksRelevant) {
-        continue;
-      }
-
-      workspaceQueue.push({
-        directoryPath: childDirectoryPath,
-        relativePath: childRelativePath,
-        markerNames: childMarkerNames,
-        depth: currentWorkspaceEntry.depth + 1,
-        underWorkspaceContainer: currentWorkspaceEntry.underWorkspaceContainer || isWorkspaceContainer || childIsWorkspaceContainer,
-      });
-      queuedWorkspacePaths.add(childRelativePath);
-    }
-  }
-
-  return nestedWorkspaceProjects;
-}

package/lib/cli/detector.mjs

@@ -1,23 +0,0 @@
-/**
- * Stack Detector — project context auto-detection. Aggregator that re-exports
- * the public surface of the detector subsystem. Implementation lives under
- * lib/cli/detector/* split per concern: workspace scan, UI signal analysis,
- * and stack detection scoring.
- *
- * Public exports:
- *   collectProjectMarkers     — read top-level markers in a directory
- *   detectProjectContext      — top-level stack detection with ranked candidates
- *   detectUiScopeSignals      — UI scope detection plus design evidence scan;
- *                               returns frontendEvidenceMetrics and
- *                               designEvidenceSummary when UI scope is detected
- *   buildDetectionSummary     — human-readable detection summary text
- *   formatDetectionCandidates — formatter for ranked detection candidates
- */
-
-export { collectProjectMarkers } from './detector/workspace-scan.mjs';
-export { detectUiScopeSignals } from './detector/ui-signals.mjs';
-export {
-  buildDetectionSummary,
-  detectProjectContext,
-  formatDetectionCandidates,
-} from './detector/stack-detection.mjs';

package/lib/cli/init-detection-flow.mjs

@@ -1,48 +0,0 @@
-export function buildExistingProjectMajorConstraints({ mode = 'init' } = {}) {
-  if (mode === 'upgrade') {
-    return [
-      'Preserve existing project markers and avoid forced stack migration.',
-      'Use runtime markers as evidence only unless the user already recorded an explicit runtime constraint.',
-      'Upgrade keeps prior explicit onboarding constraints but does not create new stack or blueprint decisions.',
-    ];
-  }
-
-  return [
-    'Preserve existing project markers and avoid forced stack migration.',
-    'Use detected runtime markers as evidence only; do not convert them into stack migration or design direction.',
-    'Explicit stack or blueprint overrides are constraints only when the user provides them.',
-  ];
-}
-
-export async function resolveDetectedSetupDecision({
-  shouldAutoApplyDetectedStack,
-  projectDetection,
-  detectionTransparency,
-  initialSelectedManualStackFileName,
-  initialSelectedManualBlueprintFileName,
-  initialSelectedAdditionalStackFileNames,
-}) {
-  let selectedManualStackFileName = initialSelectedManualStackFileName || null;
-  let selectedManualBlueprintFileName = initialSelectedManualBlueprintFileName || null;
-  let selectedAdditionalStackFileNames = initialSelectedAdditionalStackFileNames || [];
-  let detectedSetupWasApplied = false;
-
-  if (shouldAutoApplyDetectedStack) {
-    detectionTransparency.quickConfirmation.response = 'evidence-only';
-    detectionTransparency.decision.mode = 'existing-project-evidence-only';
-    selectedAdditionalStackFileNames = [];
-  } else if (projectDetection.hasExistingProjectFiles && projectDetection.detectedStackFileName) {
-    detectionTransparency.quickConfirmation.response = 'evidence-only';
-    detectionTransparency.decision.mode = 'existing-project-evidence-only';
-  } else if (!projectDetection.hasExistingProjectFiles) {
-    detectionTransparency.quickConfirmation.response = 'not-applicable';
-    detectionTransparency.decision.mode = 'fresh-agent-decision-required';
-  }
-
-  return {
-    detectedSetupWasApplied,
-    selectedManualStackFileName,
-    selectedManualBlueprintFileName,
-    selectedAdditionalStackFileNames,
-  };
-}

package/lib/cli/init-options.mjs

@@ -1,237 +0,0 @@
-/**
- * Init Options Parser — isolates CLI option parsing from init runtime flow.
- */
-import { normalizeDocsLanguage } from './project-scaffolder.mjs';
-import { normalizeAgentName } from './token-optimization.mjs';
-import { normalizeChoiceInput, matchProfileNameFromInput } from './utils.mjs';
-
-export function normalizeRuntimeEnvironmentKey(rawRuntimeEnvironmentKey) {
-  const normalizedRuntimeEnvironmentKey = normalizeChoiceInput(String(rawRuntimeEnvironmentKey || 'auto'));
-  const supportedRuntimeEnvironmentKeys = new Set(['auto', 'linux-wsl', 'linux', 'windows', 'macos']);
-  return supportedRuntimeEnvironmentKeys.has(normalizedRuntimeEnvironmentKey) ? normalizedRuntimeEnvironmentKey : null;
-}
-
-export function parseInitArguments(commandArguments) {
-  const parsedInitOptions = {
-    targetDirectory: '.',
-    preset: undefined,
-    profile: undefined,
-    stack: undefined,
-    blueprint: undefined,
-    ci: undefined,
-    newbie: false,
-    tokenOptimize: true,
-    memoryContinuity: true,
-    tokenAgent: 'copilot',
-    includeMcpTemplate: false,
-    localOnly: undefined,
-    scaffoldDocs: undefined,
-    docsLang: 'en',
-    docsLangProvided: false,
-    projectConfig: undefined,
-    projectDescription: '',
-    runtimeEnv: 'auto',
-    runtimeEnvProvided: false,
-  };
-
-  for (let argumentIndex = 0; argumentIndex < commandArguments.length; argumentIndex++) {
-    const currentArgument = commandArguments[argumentIndex];
-
-    if (!currentArgument.startsWith('--')) {
-      parsedInitOptions.targetDirectory = currentArgument;
-      continue;
-    }
-
-    if (currentArgument === '--profile') {
-      parsedInitOptions.profile = matchProfileNameFromInput(commandArguments[argumentIndex + 1] || '');
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument === '--preset') {
-      parsedInitOptions.preset = normalizeChoiceInput(commandArguments[argumentIndex + 1] || '');
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--preset=')) {
-      parsedInitOptions.preset = normalizeChoiceInput(currentArgument.split('=')[1]);
-      continue;
-    }
-
-    if (currentArgument.startsWith('--profile=')) {
-      parsedInitOptions.profile = matchProfileNameFromInput(currentArgument.split('=')[1]);
-      continue;
-    }
-
-    if (currentArgument === '--stack') {
-      parsedInitOptions.stack = commandArguments[argumentIndex + 1];
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--stack=')) {
-      parsedInitOptions.stack = currentArgument.split('=')[1];
-      continue;
-    }
-
-    if (currentArgument === '--blueprint') {
-      parsedInitOptions.blueprint = commandArguments[argumentIndex + 1];
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--blueprint=')) {
-      parsedInitOptions.blueprint = currentArgument.split('=')[1];
-      continue;
-    }
-
-    if (currentArgument === '--ci') {
-      const ciRawValue = commandArguments[argumentIndex + 1];
-      parsedInitOptions.ci = ciRawValue?.toLowerCase() === 'true';
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--ci=')) {
-      parsedInitOptions.ci = currentArgument.split('=')[1]?.toLowerCase() === 'true';
-      continue;
-    }
-
-    if (currentArgument === '--newbie') {
-      parsedInitOptions.newbie = true;
-      continue;
-    }
-
-    if (currentArgument === '--token-optimize') {
-      parsedInitOptions.tokenOptimize = true;
-      continue;
-    }
-
-    if (currentArgument === '--memory-continuity') {
-      parsedInitOptions.memoryContinuity = true;
-      continue;
-    }
-
-    if (currentArgument === '--token-agent') {
-      parsedInitOptions.tokenAgent = commandArguments[argumentIndex + 1] || 'copilot';
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--token-agent=')) {
-      parsedInitOptions.tokenAgent = currentArgument.split('=')[1] || 'copilot';
-      continue;
-    }
-
-    if (currentArgument === '--no-token-optimize') {
-      parsedInitOptions.tokenOptimize = false;
-      continue;
-    }
-
-    if (currentArgument === '--no-memory-continuity') {
-      parsedInitOptions.memoryContinuity = false;
-      continue;
-    }
-
-    if (currentArgument === '--mcp-template') {
-      parsedInitOptions.includeMcpTemplate = true;
-      continue;
-    }
-
-    if (currentArgument === '--no-mcp-template') {
-      parsedInitOptions.includeMcpTemplate = false;
-      continue;
-    }
-
-    if (currentArgument === '--local-only') {
-      parsedInitOptions.localOnly = true;
-      continue;
-    }
-
-    if (currentArgument === '--no-local-only') {
-      parsedInitOptions.localOnly = false;
-      continue;
-    }
-
-    if (currentArgument === '--scaffold-docs') {
-      parsedInitOptions.scaffoldDocs = true;
-      continue;
-    }
-
-    if (currentArgument === '--no-scaffold-docs') {
-      parsedInitOptions.scaffoldDocs = false;
-      continue;
-    }
-
-    if (currentArgument === '--docs-lang') {
-      parsedInitOptions.docsLang = commandArguments[argumentIndex + 1] || 'en';
-      parsedInitOptions.docsLangProvided = true;
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--docs-lang=')) {
-      parsedInitOptions.docsLang = currentArgument.split('=')[1] || 'en';
-      parsedInitOptions.docsLangProvided = true;
-      continue;
-    }
-
-    if (currentArgument === '--project-config') {
-      parsedInitOptions.projectConfig = commandArguments[argumentIndex + 1];
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--project-config=')) {
-      parsedInitOptions.projectConfig = currentArgument.split('=')[1];
-      continue;
-    }
-
-    if (currentArgument === '--project-description') {
-      parsedInitOptions.projectDescription = commandArguments[argumentIndex + 1] || '';
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--project-description=')) {
-      parsedInitOptions.projectDescription = currentArgument.split('=')[1] || '';
-      continue;
-    }
-
-    if (currentArgument === '--runtime-env') {
-      parsedInitOptions.runtimeEnv = commandArguments[argumentIndex + 1] || 'auto';
-      parsedInitOptions.runtimeEnvProvided = true;
-      argumentIndex += 1;
-      continue;
-    }
-
-    if (currentArgument.startsWith('--runtime-env=')) {
-      parsedInitOptions.runtimeEnv = currentArgument.split('=')[1] || 'auto';
-      parsedInitOptions.runtimeEnvProvided = true;
-      continue;
-    }
-
-    throw new Error(`Unknown option: ${currentArgument}`);
-  }
-
-  if (parsedInitOptions.newbie && parsedInitOptions.profile && parsedInitOptions.profile !== 'beginner') {
-    throw new Error('--newbie can only be combined with --profile beginner');
-  }
-
-  const normalizedDocsLanguage = normalizeDocsLanguage(parsedInitOptions.docsLang || 'en');
-  if (!normalizedDocsLanguage) {
-    throw new Error('--docs-lang must be one of: en, id');
-  }
-
-  const normalizedRuntimeEnvironment = normalizeRuntimeEnvironmentKey(parsedInitOptions.runtimeEnv || 'auto');
-  if (!normalizedRuntimeEnvironment) {
-    throw new Error('--runtime-env must be one of: auto, linux-wsl, linux, windows, macos');
-  }
-
-  parsedInitOptions.docsLang = normalizedDocsLanguage;
-  parsedInitOptions.runtimeEnv = normalizedRuntimeEnvironment;
-  parsedInitOptions.tokenAgent = normalizeAgentName(parsedInitOptions.tokenAgent);
-
-  return parsedInitOptions;
-}

package/lib/cli/init-selection.mjs

@@ -1,29 +0,0 @@
-/**
- * Init Selection Helpers — stack/blueprint filtering and scope normalization.
- */
-import {
-  PROJECT_SCOPE_CHOICES,
-} from './constants.mjs';
-
-export function resolveProjectScopeKeyFromLabel(selectedProjectScopeLabel) {
-  const projectScopeEntry = PROJECT_SCOPE_CHOICES.find((scopeChoice) => scopeChoice.label === selectedProjectScopeLabel);
-  return projectScopeEntry?.key || 'both';
-}
-
-export function normalizeAdditionalStackSelection(selectedStackFileName, additionalStackFileNames) {
-  if (!Array.isArray(additionalStackFileNames) || additionalStackFileNames.length === 0) {
-    return [];
-  }
-
-  return Array.from(new Set(additionalStackFileNames.filter((stackFileName) => stackFileName && stackFileName !== selectedStackFileName)));
-}
-
-export function normalizeAdditionalBlueprintSelection(selectedBlueprintFileName, additionalBlueprintFileNames) {
-  if (!Array.isArray(additionalBlueprintFileNames) || additionalBlueprintFileNames.length === 0) {
-    return [];
-  }
-
-  return Array.from(new Set(additionalBlueprintFileNames.filter(
-    (blueprintFileName) => blueprintFileName && blueprintFileName !== selectedBlueprintFileName
-  )));
-}