@open-dy/vibecoding-cli 0.0.1-beta.1

package/src/adapters/interest-card/opencard/validate.mjs

@@ -0,0 +1,11 @@
+// Internal entry used by both the CLI and the original parallel lint script.
+const [root, name] = process.argv.slice(2)
+const modules = {
+  'opencard-structure': './validate-opencard-structure.mjs',
+  'widget-shell': './validate-widget-shell.mjs',
+  'lynx-css': './lint-lynx-css.mjs',
+}
+if (!root || !Object.hasOwn(modules, name)) throw new Error('Expected project root and validator name')
+process.env.VIBECODING_OPENCARD_ROOT = root
+const { main } = await import(modules[name])
+main()

package/src/adapters/interest-card/opencard/write-web-config.mjs

@@ -0,0 +1,17 @@
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const outputRoot = process.argv[2]?.trim();
+if (!outputRoot) {
+  throw new Error('write-web-config requires an output root');
+}
+
+const config = {
+  hasAuditDouyinCloud: true,
+};
+
+await writeFile(
+  path.resolve(outputRoot, 'web.config.json'),
+  `${JSON.stringify(config, null, 2)}\n`,
+  'utf8',
+);

package/src/build/opencard-environment.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/** Locate host routing for standalone preview callers without a resolved CLI context. */
+function findRoutingPath(cardRoot) {
+  let root = path.dirname(path.resolve(cardRoot))
+  while (true) {
+    const file = path.join(root, 'config/card-routing.json')
+    if (fs.existsSync(file)) return file
+    // Do not borrow configuration from outside the owning project/repository.
+    if (fs.existsSync(path.join(root, 'package.json')) || fs.existsSync(path.join(root, '.git'))) return file
+    const parent = path.dirname(root)
+    if (parent === root) return file
+    root = parent
+  }
+}
+
+/** Read the host configuration; missing routing retains the legacy open-domain default. */
+export function resolveCardRoutingPath(context) {
+  return context.taroRoot
+    ? path.join(context.taroRoot, 'config/card-routing.json')
+    : findRoutingPath(context.root)
+}
+
+export function readCardRouting(context) {
+  const file = resolveCardRoutingPath(context)
+  let raw
+  try {
+    raw = fs.readFileSync(file, 'utf8')
+  } catch (error) {
+    if (error.code === 'ENOENT') return {}
+    throw error
+  }
+  let routing
+  try {
+    routing = JSON.parse(raw)
+  } catch (error) {
+    throw new Error(`${file} must contain valid JSON: ${error.message}`)
+  }
+  if (!['closed', 'open', 'none', undefined].includes(routing?.cardData?.serviceDomain)) {
+    throw new Error(`${file} cardData.serviceDomain must be none, open, or closed`)
+  }
+  return routing
+}
+
+/** Pass to the compiler child only; never mutate the CLI process environment. */
+export function openCardBuildEnvironment(context) {
+  return { IS_CARD_CLOSED_DOMAIN: String(readCardRouting(context)?.cardData?.serviceDomain === 'closed') }
+}

package/src/build/turbo-config.mjs

@@ -0,0 +1,140 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+
+const ARRAY_FIELDS = new Set(['env', 'inputs', 'outputs', 'dependsOn'])
+
+// These settings are part of the CLI contract. They are kept here, rather
+// than in generated projects, so all projects receive the same cache key and
+// closed-domain environment behavior as the CLI is upgraded.
+const OPENCARD_DEFAULTS = {
+  tasks: {
+    'build:raw': {
+      env: ['IS_CARD_CLOSED_DOMAIN'],
+      inputs: ['../config/card-routing.json'],
+    },
+  },
+}
+
+const TARO_DEFAULTS = {
+  tasks: {
+    '//#build:tt:raw': {
+      env: ['IS_CARD_CLOSED_DOMAIN'],
+      inputs: ['config/card-routing.json'],
+    },
+  },
+}
+
+function clone(value) {
+  if (Array.isArray(value)) return value.map(clone)
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, clone(entry)]))
+  }
+  return value
+}
+
+function mergeValues(defaultValue, projectValue, key) {
+  if (ARRAY_FIELDS.has(key) && Array.isArray(projectValue)) {
+    return [...new Set([...(Array.isArray(defaultValue) ? defaultValue : []), ...projectValue])]
+  }
+  if (Array.isArray(defaultValue) && Array.isArray(projectValue)) {
+    return [...new Set([...defaultValue, ...projectValue])]
+  }
+  if (
+    defaultValue && typeof defaultValue === 'object' &&
+    projectValue && typeof projectValue === 'object' &&
+    !Array.isArray(defaultValue) && !Array.isArray(projectValue)
+  ) {
+    return mergeObject(defaultValue, projectValue)
+  }
+  return clone(projectValue === undefined ? defaultValue : projectValue)
+}
+
+function mergeObject(defaultObject, projectObject) {
+  const result = clone(defaultObject)
+  for (const [key, projectValue] of Object.entries(projectObject ?? {})) {
+    result[key] = mergeValues(result[key], projectValue, key)
+  }
+  return result
+}
+
+function ensureRequiredTargetConfig(config, defaults) {
+  const taskName = Object.keys(defaults.tasks)[0]
+  const tasks = config.tasks && typeof config.tasks === 'object' && !Array.isArray(config.tasks)
+    ? config.tasks
+    : {}
+  const task = tasks[taskName] && typeof tasks[taskName] === 'object' && !Array.isArray(tasks[taskName])
+    ? tasks[taskName]
+    : {}
+  for (const field of ['env', 'inputs']) {
+    const required = defaults.tasks[Object.keys(defaults.tasks)[0]][field]
+    const project = Array.isArray(task[field]) ? task[field] : []
+    task[field] = [...new Set([...required, ...project])]
+  }
+  tasks[taskName] = task
+  config.tasks = tasks
+  return config
+}
+
+export function mergeTurboConfig(defaultConfig, projectConfig) {
+  return mergeObject(defaultConfig, projectConfig)
+}
+
+export function readTurboConfig(projectRoot) {
+  const file = path.join(projectRoot, 'turbo.json')
+  if (!existsSync(file)) return {}
+  try {
+    const config = JSON.parse(readFileSync(file, 'utf8'))
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      throw new Error('the root value must be a JSON object')
+    }
+    if ('tasks' in config && (!config.tasks || typeof config.tasks !== 'object' || Array.isArray(config.tasks))) {
+      throw new Error('tasks must be a JSON object')
+    }
+    for (const [taskName, task] of Object.entries(config.tasks ?? {})) {
+      if (!task || typeof task !== 'object' || Array.isArray(task)) {
+        throw new Error(`tasks.${taskName} must be a JSON object`)
+      }
+      for (const field of ARRAY_FIELDS) {
+        if (field in task && !Array.isArray(task[field])) {
+          throw new Error(`tasks.${taskName}.${field} must be an array`)
+        }
+      }
+    }
+    return config
+  } catch (error) {
+    throw new CliError(`Cannot read ${file}: ${error.message}`)
+  }
+}
+
+export function resolveTurboDefaults({ target }) {
+  if (target === 'opencard') return clone(OPENCARD_DEFAULTS)
+  if (target === 'taro') return clone(TARO_DEFAULTS)
+  return {}
+}
+
+export function resolveTurboConfig({ projectRoot, target }) {
+  const config = mergeTurboConfig(resolveTurboDefaults({ target }), readTurboConfig(projectRoot))
+  const defaults = resolveTurboDefaults({ target })
+  return target === 'opencard' || target === 'taro'
+    ? ensureRequiredTargetConfig(config, defaults)
+    : config
+}
+
+export function writeTurboConfig(projectRoot, config) {
+  const directory = path.join(projectRoot, '.vibecoding', 'cache')
+  const file = path.join(directory, 'turbo.json')
+  mkdirSync(directory, { recursive: true })
+  const content = `${JSON.stringify(config, null, 2)}\n`
+  try {
+    if (readFileSync(file, 'utf8') === content) return file
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
+  writeFileSync(file, content)
+  return file
+}
+
+export function prepareTurboConfig({ projectRoot, target }) {
+  return writeTurboConfig(projectRoot, resolveTurboConfig({ projectRoot, target }))
+}

package/src/cli.mjs

@@ -0,0 +1,104 @@
+import { parseArgs, requireTarget, resolveBuildScope } from './core/args.mjs'
+import { inferProjectTarget, resolveProjectContext } from './core/context.mjs'
+import { UsageError } from './core/errors.mjs'
+import { runBuild } from './commands/build.mjs'
+import { runDatabaseInit } from './commands/db.mjs'
+import { runDevWatch } from './preview/dev-watch.mjs'
+import { runDev } from './commands/dev.mjs'
+import { runLint } from './commands/lint.mjs'
+import { runPack } from './commands/pack.mjs'
+import { runValidate } from './commands/validate.mjs'
+import { runVerify } from './commands/verify.mjs'
+import { runTurbo } from './commands/turbo.mjs'
+
+const HELP = `Usage: vibecoding <command> [options]
+
+Commands:
+  dev                    Start development services and previews
+  dev-watch              Start only the frontend preview
+  build                  Build the selected target
+  lint                   Type-check, lint and validate source structure
+  verify                 Run static and/or runtime verification
+  validate <name>        Run feed-card, routes, empty or opencard-structure
+  init-mysql-db          Initialize the Taro server database
+  pack                   Build deployment archives
+  turbo <args...>        Run Turbo with CLI defaults and project config
+
+Required:
+  --target taro|opencard Required by project commands; turbo can infer it from the project root
+
+Options:
+  --cwd <path>           Project directory (default: current directory)
+  --scope tt             Build only the Taro TT output
+  --skip-install         Do not install dependencies before dev
+  --skip-root-install    Skip the root install but still install nested targets before dev
+  --incremental          Lint changed files when possible
+  --full                 Verify static and runtime phases
+  --runtime-only         Verify runtime only
+  --static-only          Verify static phase only
+  --ports-only           Verify listening ports only
+  --auto-start           Start dev once when verify finds missing ports
+  --timeout <seconds>    Dev startup timeout (default: 90)
+  --frontend-url <url>   Override the primary runtime-check URL`
+
+function assertNoExtra(positionals, count, command) {
+  if (positionals.length > count) throw new UsageError(`Unexpected argument for ${command}: ${positionals[count]}`)
+}
+
+/**
+ * @desc 解析 vibecoding 命令行参数并调度对应的工程操作。
+ * @params {string[]} [argv] 命令行参数；默认读取 process.argv。
+ * @return {Promise<void>} 命令执行完成的 Promise。
+ * @example main(['build', '--target', 'taro'])
+ */
+export async function main(argv = process.argv.slice(2)) {
+  const { positionals, flags, passthrough } = parseArgs(argv)
+  const command = positionals[0]
+  if (flags.help || !command) {
+    console.log(HELP)
+    return
+  }
+  if (command === 'turbo') {
+    const target = flags.target ?? inferProjectTarget({ cwd: flags.cwd })
+    const context = resolveProjectContext({ cwd: flags.cwd, target })
+    return runTurbo(context, {
+      args: [...positionals.slice(1), ...passthrough],
+    })
+  }
+
+  const target = requireTarget(flags)
+  const scope = resolveBuildScope(command, target, flags)
+  const context = resolveProjectContext({ cwd: flags.cwd, target })
+  const options = {
+    skipInstall: flags['skip-install'],
+    skipRootInstall: flags['skip-root-install'],
+    incremental: flags.incremental,
+    full: flags.full,
+    runtimeOnly: flags['runtime-only'],
+    staticOnly: flags['static-only'],
+    portsOnly: flags['ports-only'],
+    autoStart: flags['auto-start'],
+    timeoutSeconds: flags.timeout ? Number(flags.timeout) : 90,
+    frontendUrl: flags['frontend-url'],
+    scope,
+  }
+  if (!Number.isFinite(options.timeoutSeconds) || options.timeoutSeconds <= 0) {
+    throw new UsageError('--timeout must be a positive number')
+  }
+
+  switch (command) {
+    case 'dev': assertNoExtra(positionals, 1, command); return runDev(context, options)
+    case 'dev-watch':
+      assertNoExtra(positionals, 1, command)
+      return runDevWatch({ root: context.root, cardMode: target === 'opencard' })
+    case 'build': assertNoExtra(positionals, 1, command); return runBuild(context, options)
+    case 'lint': assertNoExtra(positionals, 1, command); return runLint(context, options)
+    case 'verify': assertNoExtra(positionals, 1, command); return runVerify(context, options)
+    case 'pack': assertNoExtra(positionals, 1, command); return runPack(context, options)
+    case 'init-mysql-db': assertNoExtra(positionals, 1, command); return runDatabaseInit(context)
+    case 'validate':
+      assertNoExtra(positionals, 2, command)
+      return runValidate(context, positionals[1])
+    default: throw new UsageError(`Unknown command: ${command}\n\n${HELP}`)
+  }
+}

package/src/commands/build.mjs

@@ -0,0 +1,138 @@
+import { openCardBuildEnvironment } from '../build/opencard-environment.mjs'
+import { mkdirSync } from 'node:fs'
+import path from 'node:path'
+import { readEnvFile } from '../core/environment.mjs'
+import { resolveProjectBinary, resolveSdkTaroEntry, runProcess, runTasks } from '../core/runner.mjs'
+import { writeWebConfig } from '../core/web-config.mjs'
+import { validateRoutes } from '../validators/routes.mjs'
+
+function taroEnvironment(root, extra = {}) {
+  const home = path.join(root, '.home')
+  mkdirSync(home, { recursive: true })
+  return { HOME: home, ...extra }
+}
+
+export function resolveBuildEnvironment(root, explicit = {}) {
+  return { ...readEnvFile(root), ...explicit }
+}
+
+export async function buildTaroFrontend(context, type, options = {}) {
+  const args = ['build', '--type', type]
+  if (options.mode) args.push('--mode', options.mode)
+  if (options.watch) args.push('--watch')
+  await runProcess(resolveProjectBinary(context.taroRoot, 'taro'), args, {
+    cwd: context.taroRoot,
+    env: taroEnvironment(context.taroRoot, options.env),
+    label: `taro ${type} build`,
+  })
+  if (type === 'tt' && !options.watch) {
+    writeWebConfig(path.join(context.taroRoot, 'dist-tt'))
+  }
+}
+
+export async function buildOpenCard(context, options = {}) {
+  const root = context.target === 'opencard' ? context.root : context.opencardRoot
+  if (!root) return
+  const args = ['build', '--type', 'tt']
+  if (options.mode) args.push('--mode', options.mode)
+  if (options.watch) args.push('--watch')
+  await runProcess(process.execPath, [resolveSdkTaroEntry(root), ...args], {
+    cwd: root,
+    env: taroEnvironment(root, {
+      ...(options.watch ? { TT_OUTPUT_ROOT: 'dist-tt' } : {}),
+      ...options.env,
+      ...openCardBuildEnvironment(context),
+    }),
+    label: 'opencard tt build',
+  })
+  if (!options.watch) {
+    writeWebConfig(path.join(root, options.env?.TT_OUTPUT_ROOT?.trim() || 'dist'))
+  }
+}
+
+export function resolveServerBuildScript(options = {}) {
+  return options.production ? 'build:prod' : 'build'
+}
+
+export function buildServer(context, options = {}) {
+  return runProcess('pnpm', [
+    '--filter', 'server', 'run', resolveServerBuildScript(options),
+  ], {
+    cwd: context.taroRoot,
+    env: options.env,
+    label: 'server build',
+  })
+}
+
+export function buildClosedDomainServer(context, options = {}) {
+  return runProcess('pnpm', ['--filter', 'closed-domain-server', 'run', 'build'], {
+    cwd: context.taroRoot,
+    env: options.env,
+    label: 'closed-domain-server build',
+  })
+}
+
+/**
+ * Build the inputs consumed by the deployment packer before it creates
+ * deployment archives. This stays internal to `pack`; the generic template
+ * exposes only the stable `pack.sh` entrypoint.
+ */
+export async function buildPackInputs(context, options = {}) {
+  const tasks = [
+    { name: 'taro-tt', run: () => buildTaroFrontend(context, 'tt', { ...options, mode: 'prod' }) },
+    { name: 'server', run: () => buildServer(context, { ...options, production: true }) },
+  ]
+  if (context.hasClosedDomainServer) {
+    tasks.push({ name: 'closed-domain-server', run: () => buildClosedDomainServer(context, options) })
+  }
+  if (context.hasOpenCard) {
+    tasks.push({ name: 'opencard', run: () => buildOpenCard(context, options) })
+  }
+  await runTasks(tasks, { label: 'pack build' })
+}
+
+export async function runBuild(context, options = {}) {
+  const buildOptions = {
+    ...options,
+    env: resolveBuildEnvironment(context.root, options.env),
+  }
+  if (context.target === 'opencard') {
+    await buildOpenCard(context, buildOptions)
+    return
+  }
+
+  const scope = buildOptions.scope ?? 'all'
+  if (scope === 'tt') {
+    await buildTaroFrontend(context, 'tt', {
+      ...buildOptions,
+      mode: buildOptions.mode ?? 'prod',
+    })
+    return
+  }
+  if (scope === 'h5') {
+    await buildTaroFrontend(context, 'h5', buildOptions)
+    return
+  }
+  if (scope === 'server') {
+    await buildServer(context, buildOptions)
+    return
+  }
+  // Preview Runner consumes TT output. Verification selects that target while
+  // the public build command retains its existing standalone H5 default.
+  const frontendTarget = buildOptions.frontendTarget ?? 'h5'
+  const frontendOptions = frontendTarget === 'tt'
+    ? { ...buildOptions, mode: buildOptions.mode ?? 'prod' }
+    : buildOptions
+  const tasks = [
+    { name: `taro-${frontendTarget}`, run: () => buildTaroFrontend(context, frontendTarget, frontendOptions) },
+    { name: 'server', run: () => buildServer(context, buildOptions) },
+  ]
+  if (context.hasClosedDomainServer) {
+    tasks.push({ name: 'closed-domain-server', run: () => buildClosedDomainServer(context, buildOptions) })
+  }
+  if (context.hasOpenCard) {
+    tasks.push({ name: 'opencard', run: () => buildOpenCard(context, buildOptions) })
+  }
+  await runTasks(tasks, { label: 'build' })
+  validateRoutes(context)
+}

package/src/commands/db.mjs

@@ -0,0 +1,14 @@
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+import { runProcess } from '../core/runner.mjs'
+
+export async function runDatabaseInit(context, options = {}) {
+  if (context.target !== 'taro') {
+    throw new CliError('Database initialization requires --target taro')
+  }
+  await runProcess(process.execPath, [path.join(context.serverRoot, 'scripts/init-mysql-db.js')], {
+    cwd: context.serverRoot,
+    env: options.env,
+    label: 'database initialization',
+  })
+}