@open-mercato/cli 0.4.9-develop-db9ecc46fc → 0.4.9-develop-d989387b7a

package/src/lib/modules-config.ts

@@ -0,0 +1,393 @@
+import fs from 'node:fs'
+import ts from 'typescript'
+import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
+
+export type ModuleEntry = {
+  id: string
+  from?: '@open-mercato/core' | '@app' | string
+}
+
+type ModuleOccurrence = {
+  entry: ModuleEntry
+  node: ts.ObjectLiteralExpression
+}
+
+type ModuleConfigShape = {
+  arrayNode: ts.ArrayLiteralExpression
+  occurrences: ModuleOccurrence[]
+}
+
+function parseModuleEntryFromObjectLiteral(node: ts.ObjectLiteralExpression): ModuleEntry | null {
+  let id: string | null = null
+  let from: string | null = null
+
+  for (const property of node.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) continue
+
+    if (property.name.text === 'id' && ts.isStringLiteralLike(property.initializer)) {
+      id = property.initializer.text
+    }
+
+    if (property.name.text === 'from' && ts.isStringLiteralLike(property.initializer)) {
+      from = property.initializer.text
+    }
+  }
+
+  if (!id) return null
+
+  return {
+    id,
+    from: from ?? '@open-mercato/core',
+  }
+}
+
+function parseProcessEnvAccess(
+  node: ts.Expression,
+  env: NodeJS.ProcessEnv,
+): { matched: boolean; value: string | undefined } {
+  if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+    const target = node.expression
+    if (
+      ts.isPropertyAccessExpression(target)
+      && ts.isIdentifier(target.expression)
+      && target.expression.text === 'process'
+      && target.name.text === 'env'
+    ) {
+      return { matched: true, value: env[node.name.text] }
+    }
+  }
+
+  if (
+    ts.isElementAccessExpression(node)
+    && ts.isPropertyAccessExpression(node.expression)
+    && ts.isIdentifier(node.expression.expression)
+    && node.expression.expression.text === 'process'
+    && node.expression.name.text === 'env'
+    && ts.isStringLiteralLike(node.argumentExpression)
+  ) {
+    return { matched: true, value: env[node.argumentExpression.text] }
+  }
+
+  return { matched: false, value: undefined }
+}
+
+function evaluateStaticExpressionWithScope(
+  node: ts.Expression,
+  env: NodeJS.ProcessEnv,
+  scope: Map<string, unknown>,
+): unknown {
+  if (ts.isParenthesizedExpression(node)) {
+    return evaluateStaticExpressionWithScope(node.expression, env, scope)
+  }
+
+  if (ts.isIdentifier(node)) {
+    return scope.get(node.text)
+  }
+
+  if (ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text
+  }
+
+  if (ts.isNumericLiteral(node)) {
+    return Number(node.text)
+  }
+
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false
+  if (node.kind === ts.SyntaxKind.NullKeyword) return null
+
+  const envAccess = parseProcessEnvAccess(node, env)
+  if (envAccess.matched) {
+    return envAccess.value
+  }
+
+  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
+    return !Boolean(evaluateStaticExpressionWithScope(node.operand, env, scope))
+  }
+
+  if (ts.isBinaryExpression(node)) {
+    if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+      return Boolean(evaluateStaticExpressionWithScope(node.left, env, scope))
+        && Boolean(evaluateStaticExpressionWithScope(node.right, env, scope))
+    }
+
+    if (node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+      return Boolean(evaluateStaticExpressionWithScope(node.left, env, scope))
+        || Boolean(evaluateStaticExpressionWithScope(node.right, env, scope))
+    }
+
+    if (node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
+      return evaluateStaticExpressionWithScope(node.left, env, scope)
+        === evaluateStaticExpressionWithScope(node.right, env, scope)
+    }
+
+    if (node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+      return evaluateStaticExpressionWithScope(node.left, env, scope)
+        !== evaluateStaticExpressionWithScope(node.right, env, scope)
+    }
+  }
+
+  if (
+    ts.isCallExpression(node)
+    && ts.isIdentifier(node.expression)
+    && node.expression.text === 'parseBooleanWithDefault'
+  ) {
+    const rawValueNode = node.arguments[0]
+    const fallbackNode = node.arguments[1]
+    const rawValue = rawValueNode
+      ? evaluateStaticExpressionWithScope(rawValueNode, env, scope)
+      : undefined
+    const fallbackValue = fallbackNode
+      ? evaluateStaticExpressionWithScope(fallbackNode, env, scope)
+      : false
+
+    return parseBooleanWithDefault(
+      typeof rawValue === 'string' ? rawValue : undefined,
+      Boolean(fallbackValue),
+    )
+  }
+
+  return undefined
+}
+
+function evaluateStaticCondition(
+  node: ts.Expression,
+  env: NodeJS.ProcessEnv,
+  scope: Map<string, unknown>,
+): boolean {
+  return Boolean(evaluateStaticExpressionWithScope(node, env, scope))
+}
+
+function collectPushEntriesFromStatement(
+  statement: ts.Statement,
+  env: NodeJS.ProcessEnv,
+  targetVariableName: string,
+  scope: Map<string, unknown>,
+): ModuleOccurrence[] {
+  if (ts.isBlock(statement)) {
+    return statement.statements.flatMap((child) =>
+      collectPushEntriesFromStatement(child, env, targetVariableName, scope),
+    )
+  }
+
+  if (ts.isIfStatement(statement)) {
+    if (evaluateStaticCondition(statement.expression, env, scope)) {
+      return collectPushEntriesFromStatement(statement.thenStatement, env, targetVariableName, scope)
+    }
+
+    if (statement.elseStatement) {
+      return collectPushEntriesFromStatement(statement.elseStatement, env, targetVariableName, scope)
+    }
+
+    return []
+  }
+
+  if (!ts.isExpressionStatement(statement)) return []
+
+  const expression = statement.expression
+  if (!ts.isCallExpression(expression) || !ts.isPropertyAccessExpression(expression.expression)) {
+    return []
+  }
+
+  const pushTarget = expression.expression.expression
+  const pushMethod = expression.expression.name
+
+  if (!ts.isIdentifier(pushTarget) || pushTarget.text !== targetVariableName || pushMethod.text !== 'push') {
+    return []
+  }
+
+  return expression.arguments.flatMap((argument) => {
+    if (!ts.isObjectLiteralExpression(argument)) return []
+    const entry = parseModuleEntryFromObjectLiteral(argument)
+    return entry ? [{ entry, node: argument }] : []
+  })
+}
+
+function parseModuleConfigShape(
+  source: string,
+  env: NodeJS.ProcessEnv = process.env,
+): ModuleConfigShape {
+  const sourceFile = ts.createSourceFile('modules.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const variableName = 'enabledModules'
+  const occurrences: ModuleOccurrence[] = []
+  const scope = new Map<string, unknown>()
+  let arrayNode: ts.ArrayLiteralExpression | null = null
+  let foundDeclaration = false
+
+  for (const statement of sourceFile.statements) {
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name)) continue
+
+        if (declaration.name.text === variableName) {
+          if (!declaration.initializer || !ts.isArrayLiteralExpression(declaration.initializer)) continue
+
+          arrayNode = declaration.initializer
+          occurrences.push(...declaration.initializer.elements.flatMap((element) => {
+            if (!ts.isObjectLiteralExpression(element)) return []
+            const entry = parseModuleEntryFromObjectLiteral(element)
+            return entry ? [{ entry, node: element }] : []
+          }))
+          foundDeclaration = true
+          continue
+        }
+
+        if (!declaration.initializer) continue
+
+        scope.set(
+          declaration.name.text,
+          evaluateStaticExpressionWithScope(declaration.initializer, env, scope),
+        )
+      }
+      continue
+    }
+
+    if (!foundDeclaration) continue
+
+    occurrences.push(...collectPushEntriesFromStatement(statement, env, variableName, scope))
+  }
+
+  if (!arrayNode) {
+    throw new Error('Could not find enabledModules array declaration in src/modules.ts')
+  }
+
+  return { arrayNode, occurrences }
+}
+
+function normalizeModuleEntry(entry: ModuleEntry): ModuleEntry {
+  return {
+    id: entry.id,
+    from: entry.from ?? '@open-mercato/core',
+  }
+}
+
+function escapeSingleQuotedString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+}
+
+function buildModuleEntryLiteral(entry: ModuleEntry): string {
+  const normalized = normalizeModuleEntry(entry)
+  return `{ id: '${escapeSingleQuotedString(normalized.id)}', from: '${escapeSingleQuotedString(normalized.from ?? '@open-mercato/core')}' }`
+}
+
+function lineIndentAt(source: string, position: number): string {
+  const lineStart = source.lastIndexOf('\n', Math.max(0, position - 1)) + 1
+  const lineToPosition = source.slice(lineStart, position)
+  const match = lineToPosition.match(/^\s*/)
+  return match?.[0] ?? ''
+}
+
+function replaceArrayLiteral(
+  source: string,
+  arrayNode: ts.ArrayLiteralExpression,
+  entry: ModuleEntry,
+  sourceFile: ts.SourceFile,
+): string {
+  const existingElements = arrayNode.elements.map((element) =>
+    source.slice(element.getStart(sourceFile), element.end).trim(),
+  )
+  const closingIndent = lineIndentAt(source, arrayNode.end - 1)
+  const elementIndent =
+    arrayNode.elements.length > 0
+      ? lineIndentAt(source, arrayNode.elements[0].getStart(sourceFile))
+      : `${closingIndent}  `
+  const updatedArray = [
+    '[',
+    ...[...existingElements, buildModuleEntryLiteral(entry)].map((value) => `${elementIndent}${value},`),
+    `${closingIndent}]`,
+  ].join('\n')
+
+  return source.slice(0, arrayNode.getStart(sourceFile)) + updatedArray + source.slice(arrayNode.end)
+}
+
+function upsertModuleSource(objectLiteral: string, from: string): string {
+  if (/from\s*:\s*'[^']*'/.test(objectLiteral)) {
+    return objectLiteral.replace(/from\s*:\s*'[^']*'/, `from: '${escapeSingleQuotedString(from)}'`)
+  }
+
+  if (/from\s*:\s*"[^"]*"/.test(objectLiteral)) {
+    return objectLiteral.replace(/from\s*:\s*"[^"]*"/, `from: "${from.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`)
+  }
+
+  return objectLiteral.replace(/\}\s*$/, `, from: '${escapeSingleQuotedString(from)}' }`)
+}
+
+export function ensureModuleRegistration(
+  modulesPath: string,
+  entry: ModuleEntry,
+): { changed: boolean; registeredAs: string } {
+  if (!fs.existsSync(modulesPath)) {
+    throw new Error(`modules.ts not found at ${modulesPath}`)
+  }
+
+  const source = fs.readFileSync(modulesPath, 'utf8')
+  const sourceFile = ts.createSourceFile('modules.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const config = parseModuleConfigShape(source)
+  const normalized = normalizeModuleEntry(entry)
+  const matches = config.occurrences.filter((occurrence) => occurrence.entry.id === normalized.id)
+
+  if (matches.length > 1) {
+    throw new Error(
+      `Module "${normalized.id}" is registered multiple times in ${modulesPath}. Resolve duplicates manually before running this command.`,
+    )
+  }
+
+  if (matches.length === 1) {
+    const existing = normalizeModuleEntry(matches[0].entry)
+    if (existing.from === normalized.from) {
+      return { changed: false, registeredAs: normalized.from ?? '@open-mercato/core' }
+    }
+
+    throw new Error(
+      `Module "${normalized.id}" is already registered from "${existing.from}". Remove or eject the existing registration first.`,
+    )
+  }
+
+  const updated = replaceArrayLiteral(source, config.arrayNode, normalized, sourceFile)
+  fs.writeFileSync(modulesPath, updated)
+
+  return { changed: true, registeredAs: normalized.from ?? '@open-mercato/core' }
+}
+
+export function setModuleRegistrationSource(
+  modulesPath: string,
+  moduleId: string,
+  from: string,
+): { changed: boolean } {
+  if (!fs.existsSync(modulesPath)) {
+    throw new Error(`modules.ts not found at ${modulesPath}`)
+  }
+
+  const source = fs.readFileSync(modulesPath, 'utf8')
+  const config = parseModuleConfigShape(source)
+  const matches = config.occurrences.filter((occurrence) => occurrence.entry.id === moduleId)
+
+  if (matches.length === 0) {
+    throw new Error(
+      `Could not find module entry for "${moduleId}" in ${modulesPath}. Expected a pattern like: { id: '${moduleId}', from: '...' } or { id: '${moduleId}' }`,
+    )
+  }
+
+  if (matches.length > 1) {
+    throw new Error(
+      `Module "${moduleId}" is registered multiple times in ${modulesPath}. Resolve duplicates manually before running this command.`,
+    )
+  }
+
+  const match = matches[0]
+  const current = normalizeModuleEntry(match.entry)
+  if (current.from === from) {
+    return { changed: false }
+  }
+
+  const objectLiteral = source.slice(match.node.getStart(), match.node.end)
+  const updatedObjectLiteral = upsertModuleSource(objectLiteral, from)
+  const updated =
+    source.slice(0, match.node.getStart()) +
+    updatedObjectLiteral +
+    source.slice(match.node.end)
+
+  fs.writeFileSync(modulesPath, updated)
+
+  return { changed: true }
+}

package/src/lib/resolver.ts

@@ -3,6 +3,25 @@ import fs from 'node:fs'
 import ts from 'typescript'
 import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
 
+/**
+ * Resolved execution environment for the CLI.
+ * Produced once by resolveEnvironment() and consumed by all subsystems.
+ * Eliminates per-subsystem isMonorepo() branching and hardcoded path segments.
+ */
+export type CliEnvironment = {
+  /** Whether the CLI is running inside a Yarn/npm workspace monorepo. */
+  mode: 'monorepo' | 'standalone'
+  /** Workspace or project root (where package.json / node_modules live). */
+  rootDir: string
+  /** Next.js application directory (contains src/, package.json, next.config.*). */
+  appDir: string
+  /**
+   * Resolve the root directory of an installed @open-mercato package.
+   * Monorepo: packages/<pkg>/   Standalone: node_modules/<pkg>/
+   */
+  packageRoot: (packageName: string) => string
+}
+
 export type ModuleEntry = {
   id: string
   from?: '@open-mercato/core' | '@app' | string
@@ -419,18 +438,24 @@ function detectMonorepoFromNodeModules(appDir: string): { isMonorepo: boolean; m
 
 export function createResolver(cwd: string = process.cwd()): PackageResolver {
   // First detect if we're in a monorepo by checking if node_modules packages are symlinks
-  const { isMonorepo: _isMonorepo, monorepoRoot } = detectMonorepoFromNodeModules(cwd)
-  const rootDir = monorepoRoot ?? cwd
+  const { isMonorepo: _isMonorepo, monorepoRoot, nodeModulesRoot } = detectMonorepoFromNodeModules(cwd)
+  // In workspaces with hoisted real directories, package sources live under the discovered node_modules root.
+  const rootDir = monorepoRoot ?? nodeModulesRoot ?? cwd
+
+  // shouldResolveAppFromRoot: true when we have a workspace/install root that differs from cwd
+  // (monorepo symlinks detected, or node_modules root found above cwd)
+  const shouldResolveAppFromRoot =
+    _isMonorepo || (nodeModulesRoot !== null && path.resolve(nodeModulesRoot) !== path.resolve(cwd))
 
   // The app directory depends on context:
   // - In monorepo: use detectAppDir to find apps/mercato or similar
   // - When symlinks not detected (e.g. Docker volume node_modules): still use apps/mercato if present at rootDir
   // - Otherwise: app is at cwd
-  const candidateAppDir = detectAppDir(rootDir, true)
+  const candidateAppDir = shouldResolveAppFromRoot ? detectAppDir(rootDir, true) : rootDir
   const appDir =
     _isMonorepo
       ? candidateAppDir
-      : candidateAppDir !== rootDir && fs.existsSync(candidateAppDir)
+      : shouldResolveAppFromRoot && candidateAppDir !== rootDir && fs.existsSync(candidateAppDir)
         ? candidateAppDir
         : cwd
 
@@ -486,3 +511,20 @@ export function createResolver(cwd: string = process.cwd()): PackageResolver {
     },
   }
 }
+
+/**
+ * Resolve the CLI execution environment as a plain value-object.
+ * Call once at subsystem init; use the returned object for all path decisions.
+ */
+export function resolveEnvironment(cwd: string = process.cwd()): CliEnvironment {
+  const resolver = createResolver(cwd)
+  const _isMonorepo = resolver.isMonorepo()
+  const rootDir = resolver.getRootDir()
+  const appDir = resolver.getAppDir()
+  return {
+    mode: _isMonorepo ? 'monorepo' : 'standalone',
+    rootDir,
+    appDir,
+    packageRoot: (packageName: string) => pkgRootFor(rootDir, packageName, _isMonorepo),
+  }
+}

package/src/lib/testing/__tests__/integration-discovery.test.ts

@@ -109,4 +109,34 @@ describe('integration discovery', () => {
       'packages/create-app/template/src/modules/auth/__integration__/TC-AUTH-001.spec.ts',
     ])
   })
+
+  it('discovers standalone app integration tests from src/modules', async () => {
+    await writeTestFile(tempRoot, 'src/modules/auth/.gitkeep')
+    await writeTestFile(tempRoot, 'src/modules/sales/.gitkeep')
+    await writeTestFile(
+      tempRoot,
+      'src/modules/sales/__integration__/TC-SALES-020.spec.ts',
+      'export {}\n',
+    )
+
+    const discovered = discoverIntegrationSpecFiles(tempRoot, path.join(tempRoot, '.ai', 'qa', 'tests'))
+    expect(discovered.map((entry) => entry.path)).toEqual([
+      'src/modules/sales/__integration__/TC-SALES-020.spec.ts',
+    ])
+  })
+
+  it('discovers standalone package integration tests from node_modules/@open-mercato', async () => {
+    await writeTestFile(tempRoot, 'src/modules/customers/.gitkeep')
+    await writeTestFile(tempRoot, 'node_modules/@open-mercato/core/src/modules/customers/.gitkeep')
+    await writeTestFile(
+      tempRoot,
+      'node_modules/@open-mercato/core/src/modules/customers/__integration__/TC-CRM-020.spec.ts',
+      'export {}\n',
+    )
+
+    const discovered = discoverIntegrationSpecFiles(tempRoot, path.join(tempRoot, '.ai', 'qa', 'tests'))
+    expect(discovered.map((entry) => entry.path)).toEqual([
+      'node_modules/@open-mercato/core/src/modules/customers/__integration__/TC-CRM-020.spec.ts',
+    ])
+  })
 })

package/src/lib/testing/integration-discovery.ts

@@ -96,31 +96,44 @@ function collectDirectDirectoryNames(directoryPath: string): string[] {
     .map((entry) => entry.name)
 }
 
+function collectModuleIdsFromModulesRoot(modulesRoot: string, enabledModules: Set<string>): void {
+  for (const moduleName of collectDirectDirectoryNames(modulesRoot)) {
+    enabledModules.add(normalizeModuleId(moduleName))
+  }
+}
+
 function resolveEnabledModuleIds(projectRoot: string): Set<string> {
   const enabledModules = new Set<string>()
+  const appModulesRoot = path.join(projectRoot, 'src', 'modules')
   const appsRoot = path.join(projectRoot, 'apps')
   const packagesRoot = path.join(projectRoot, 'packages')
+  const installedPackagesRoot = path.join(projectRoot, 'node_modules', '@open-mercato')
   const enterpriseEnabled = isEnterpriseModulesEnabled()
 
+  // Standalone app: src/modules at project root
+  collectModuleIdsFromModulesRoot(appModulesRoot, enabledModules)
+
   for (const appName of collectDirectDirectoryNames(appsRoot)) {
     const moduleRoot = path.join(appsRoot, appName, 'src', 'modules')
-    for (const moduleName of collectDirectDirectoryNames(moduleRoot)) {
-      enabledModules.add(normalizeModuleId(moduleName))
-    }
+    collectModuleIdsFromModulesRoot(moduleRoot, enabledModules)
   }
   for (const packageName of collectDirectDirectoryNames(packagesRoot)) {
     if (packageName === 'enterprise' && !enterpriseEnabled) {
       continue
     }
     const moduleRoot = path.join(packagesRoot, packageName, 'src', 'modules')
-    for (const moduleName of collectDirectDirectoryNames(moduleRoot)) {
-      enabledModules.add(normalizeModuleId(moduleName))
+    collectModuleIdsFromModulesRoot(moduleRoot, enabledModules)
+  }
+  // Standalone app: installed @open-mercato packages in node_modules
+  for (const packageName of collectDirectDirectoryNames(installedPackagesRoot)) {
+    if (packageName === 'enterprise' && !enterpriseEnabled) {
+      continue
     }
+    const moduleRoot = path.join(installedPackagesRoot, packageName, 'src', 'modules')
+    collectModuleIdsFromModulesRoot(moduleRoot, enabledModules)
   }
   const createAppTemplateModulesRoot = path.join(projectRoot, 'packages', 'create-app', 'template', 'src', 'modules')
-  for (const moduleName of collectDirectDirectoryNames(createAppTemplateModulesRoot)) {
-    enabledModules.add(normalizeModuleId(moduleName))
-  }
+  collectModuleIdsFromModulesRoot(createAppTemplateModulesRoot, enabledModules)
 
   return enabledModules
 }
@@ -223,8 +236,10 @@ export function discoverIntegrationSpecFiles(projectRoot: string, legacyIntegrat
   const overlayRoot = resolveOverlayRootPath()
   const enterpriseEnabled = isEnterpriseModulesEnabled()
   const discoveryRoots = [
+    path.join(projectRoot, 'src', 'modules'),
     path.join(projectRoot, 'apps'),
     path.join(projectRoot, 'packages'),
+    path.join(projectRoot, 'node_modules', '@open-mercato'),
   ]
 
   for (const specFile of collectSpecFilesFromDirectory(legacyIntegrationRoot)) {