vstruct-cli 0.1.0

package/src/cli.js

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// vstruct — CLI para proyectos Vue 3 con estructura 100% predecible
+//
+// Uso:
+//   vstruct new <nombre>
+//   vstruct g|c|p|s|sv|co|l <nombre>
+//   vstruct analyze
+//   vstruct init
+//   vstruct manifest
+// ---------------------------------------------------------------------------
+
+import { newProject, NewProjectError } from './commands/new.js'
+import { generate, GenerateError } from './commands/generate.js'
+import { VSTRUCT_MANIFEST } from './templates/index.js'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+// ---------------------------------------------------------------------------
+// Arg parser
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const args = []
+  const flags = {}
+
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i]
+    if (token.startsWith('--')) {
+      const key = token.slice(2)
+      const next = argv[i + 1]
+      if (next && !next.startsWith('--')) {
+        flags[key] = next
+        i++
+      } else {
+        flags[key] = true
+      }
+    } else {
+      args.push(token)
+    }
+  }
+
+  return { args, flags }
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+function runNew(args, flags) {
+  const name = args[0]
+  if (!name) {
+    console.error('Error: vstruct new <nombre> — falta el nombre del proyecto')
+    process.exit(1)
+  }
+
+  try {
+    const dryRun = flags['dry-run'] === true
+    const result = newProject(name, { dryRun })
+    console.log(`\n✅ Proyecto "${name}" creado en ${result.projectDir}\n`)
+    if (!dryRun) {
+      console.log('Próximos pasos:')
+      console.log(`  cd ${name} && npm install && npm run dev\n`)
+    }
+  } catch (err) {
+    if (err instanceof NewProjectError) {
+      console.error(`Error: ${err.message}`)
+    } else {
+      console.error(err)
+    }
+    process.exit(1)
+  }
+}
+
+function runGenerate(args) {
+  const [rawType, name] = args
+
+  if (!rawType) {
+    console.error('Error: vstruct g <tipo> <nombre>')
+    console.error('Tipos: c(component) p(page) s(store) sv(service) co(composable) l(layout)')
+    process.exit(1)
+  }
+
+  if (!name) {
+    console.error(`Error: vstruct g ${rawType} <nombre> — falta el nombre`)
+    process.exit(1)
+  }
+
+  try {
+    const result = generate(rawType, name)
+    console.log(`✅ Generado: ${result.filePath}`)
+  } catch (err) {
+    if (err instanceof GenerateError) {
+      console.error(`Error: ${err.message}`)
+    } else {
+      console.error(err)
+    }
+    process.exit(1)
+  }
+}
+
+function runAnalyze() {
+  const cwd = process.cwd()
+  const manifestPath = path.join(cwd, 'vstruct.json')
+
+  if (!fs.existsSync(manifestPath)) {
+    console.error('Error: No se encontró vstruct.json. ¿Estás en un proyecto vstruct?')
+    console.error('Ejecutá: vstruct init')
+    process.exit(1)
+  }
+
+  const violations = []
+
+  // --- 1. Required directories ---
+  const srcDir = path.join(cwd, 'src')
+  if (!fs.existsSync(srcDir)) {
+    violations.push({ severity: 'error', message: 'Falta src/' })
+    console.log(formatViolations(violations))
+    process.exit(1)
+  }
+
+  const requiredDirs = [
+    'src/components/ui', 'src/components/features',
+    'src/pages', 'src/layouts', 'src/stores', 'src/services',
+    'src/composables', 'src/types', 'src/router', 'src/styles',
+  ]
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(path.join(cwd, dir))) {
+      violations.push({ severity: 'warning', message: `Falta el directorio ${dir}/` })
+    }
+  }
+
+  // --- 2. Naming conventions ---
+  function checkDir(dirPath, pattern, label) {
+    if (!fs.existsSync(dirPath)) return
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === '.gitkeep') continue
+      if (entry.isFile() && pattern && !pattern.test(entry.name)) {
+        violations.push({
+          severity: 'error',
+          message: `Naming ${label}: "${entry.name}" no sigue la convención`,
+          fix: `Renombrar a: ${suggestName(entry.name, label)}`,
+        })
+      }
+    }
+  }
+
+  function suggestName(name, label) {
+    if (label.includes('components') || label.includes('layouts')) return toPascalCase(name.replace(/\.\w+$/, '')) + '.vue'
+    if (label === 'pages') return name.replace(/\.vue$/, '').replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '') + '.vue'
+    if (label === 'stores') return name.replace(/\.\w+$/, '').replace(/^./, (c) => c.toLowerCase()) + '.store.ts'
+    if (label === 'services') return toPascalCase(name.replace(/\.\w+$/, '')) + '.service.ts'
+    if (label === 'composables') return 'use' + toPascalCase(name.replace(/^use/i, '').replace(/\.\w+$/, '')) + '.ts'
+    return name
+  }
+
+  function toPascalCase(s) { return s.charAt(0).toUpperCase() + s.slice(1) }
+
+  checkDir(path.join(cwd, 'src/components/ui'), /^[A-Z][A-Za-z0-9]*\.vue$/, 'components/ui')
+  checkDir(path.join(cwd, 'src/components/features'), /^[A-Z][A-Za-z0-9]*\.vue$/, 'components/features')
+  checkDir(path.join(cwd, 'src/pages'), /^[a-z][a-z0-9]*(-[a-z0-9]+)*\.vue$/, 'pages')
+  checkDir(path.join(cwd, 'src/layouts'), /^[A-Z][A-Za-z0-9]*\.vue$/, 'layouts')
+  checkDir(path.join(cwd, 'src/stores'), /^[a-z][A-Za-z0-9]*\.store\.ts$/, 'stores')
+  checkDir(path.join(cwd, 'src/services'), /^[A-Z][A-Za-z0-9]*\.service\.ts$/, 'services')
+  checkDir(path.join(cwd, 'src/composables'), /^use[A-Z][A-Za-z0-9]*\.ts$/, 'composables')
+
+  // --- 3. Content anti-pattern checks ---
+  function walkDir(dirPath, callback) {
+    if (!fs.existsSync(dirPath)) return
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name)
+      if (entry.isDirectory()) walkDir(fullPath, callback)
+      else if (entry.isFile() && entry.name !== '.gitkeep') callback(fullPath)
+    }
+  }
+
+  const srcRoot = path.join(cwd, 'src')
+
+  // Check .vue files for anti-patterns
+  walkDir(srcRoot, (filePath) => {
+    if (!filePath.endsWith('.vue')) return
+    const relPath = path.relative(cwd, filePath)
+    const content = fs.readFileSync(filePath, 'utf-8')
+
+    // <a href=  → should use <router-link>
+    if (/<a\s+href=["']\/(?!\/)/.test(content)) {
+      violations.push({
+        severity: 'error',
+        message: `${relPath}: <a href="/..."> detectado — usar <router-link to="...">`,
+        fix: `Reemplazar <a href="/..."> por <router-link to="/...">`,
+      })
+    }
+
+    // fetch( in .vue files (not services)
+    if (!filePath.includes('/services/') && /\bfetch\s*\(/.test(content)) {
+      violations.push({
+        severity: 'warning',
+        message: `${relPath}: fetch() en componente — mover a un service en services/`,
+        fix: `Crear un archivo en src/services/ y llamar desde ahí`,
+      })
+    }
+
+    // <script> without lang="ts"
+    const scriptTag = content.match(/<script\b([^>]*)>/)
+    if (scriptTag && !scriptTag[1].includes('lang=')) {
+      violations.push({
+        severity: 'error',
+        message: `${relPath}: <script> sin lang="ts"`,
+        fix: `Cambiar a <script setup lang="ts">`,
+      })
+    }
+
+    // <style> without scoped (non-layouts)
+    if (!filePath.includes('/layouts/')) {
+      const styleMatch = content.match(/<style\b([^>]*)>/)
+      if (styleMatch && !styleMatch[1].includes('scoped')) {
+        violations.push({
+          severity: 'warning',
+          message: `${relPath}: <style> sin scoped`,
+          fix: `Cambiar a <style scoped>`,
+        })
+      }
+    }
+  })
+
+  // Check store files for anti-patterns
+  walkDir(path.join(cwd, 'src/stores'), (filePath) => {
+    if (!filePath.endsWith('.store.ts')) return
+    const relPath = path.relative(cwd, filePath)
+    const content = fs.readFileSync(filePath, 'utf-8')
+
+    // Store importing useRouter
+    if (/useRouter/.test(content) && /from\s+['"]vue-router['"]/.test(content)) {
+      violations.push({
+        severity: 'error',
+        message: `${relPath}: store importa useRouter — dependencia circular`,
+        fix: `El componente debe hacer router.push() después de llamar al store`,
+      })
+    }
+  })
+
+  // Check service files
+  walkDir(path.join(cwd, 'src/services'), (filePath) => {
+    if (!filePath.endsWith('.service.ts')) return
+    const relPath = path.relative(cwd, filePath)
+    const content = fs.readFileSync(filePath, 'utf-8')
+
+    // Service importing stores
+    if (/import.*from\s+['"]@\/stores\//.test(content) || /import.*from\s+['"]\.\.\/stores\//.test(content)) {
+      violations.push({
+        severity: 'error',
+        message: `${relPath}: service importa store — los services son puros HTTP`,
+        fix: `El store debe orquestar el service, no al revés`,
+      })
+    }
+  })
+
+  // --- 4. Check for files in wrong places ---
+  walkDir(srcRoot, (filePath) => {
+    const relPath = path.relative(cwd, filePath)
+    const fileName = path.basename(filePath)
+
+    // .vue files outside expected dirs
+    if (fileName.endsWith('.vue') && !fileName.endsWith('.store.ts')) {
+      const isInComponents = relPath.startsWith('src/components/')
+      const isInPages = relPath.startsWith('src/pages/')
+      const isInLayouts = relPath.startsWith('src/layouts/')
+      const isAppVue = relPath === 'src/App.vue'
+      if (!isInComponents && !isInPages && !isInLayouts && !isAppVue) {
+        violations.push({
+          severity: 'error',
+          message: `${relPath}: .vue fuera de components/, pages/, o layouts/`,
+          fix: `Mover a la carpeta correcta según la tabla canónica`,
+        })
+      }
+    }
+
+    // .store.ts outside stores/
+    if (fileName.endsWith('.store.ts') && !relPath.startsWith('src/stores/')) {
+      violations.push({
+        severity: 'error',
+        message: `${relPath}: .store.ts fuera de src/stores/`,
+        fix: `Mover a src/stores/`,
+      })
+    }
+
+    // .service.ts outside services/
+    if (fileName.endsWith('.service.ts') && !relPath.startsWith('src/services/')) {
+      violations.push({
+        severity: 'error',
+        message: `${relPath}: .service.ts fuera de src/services/`,
+        fix: `Mover a src/services/`,
+      })
+    }
+  })
+
+  console.log(formatViolations(violations))
+
+  const errors = violations.filter((v) => v.severity === 'error')
+  if (errors.length > 0) process.exit(1)
+  process.exit(0)
+}
+
+function formatViolations(violations) {
+  if (violations.length === 0) {
+    return '✅ Estructura del proyecto válida — 0 violaciones.\n'
+  }
+
+  const errors = violations.filter((v) => v.severity === 'error')
+  const warnings = violations.filter((v) => v.severity === 'warning')
+
+  let output = `\n🔍 Análisis de estructura — ${violations.length} violaciones encontradas.\n\n`
+
+  for (const v of errors) {
+    output += `  ❌ ${v.message}\n`
+    if (v.fix) output += `     💡 fix: ${v.fix}\n`
+  }
+  for (const v of warnings) {
+    output += `  ⚠️  ${v.message}\n`
+    if (v.fix) output += `     💡 fix: ${v.fix}\n`
+  }
+
+  output += `\n  Errores: ${errors.length} | Warnings: ${warnings.length}\n`
+  return output
+}
+
+function runInit(args) {
+  const cwd = process.cwd()
+  const manifestPath = path.join(cwd, 'vstruct.json')
+
+  if (fs.existsSync(manifestPath) && !args.includes('--force')) {
+    console.error('Error: vstruct.json ya existe. Usá --force para sobrescribir.')
+    process.exit(1)
+  }
+
+  const projectName = path.basename(cwd)
+  const content = VSTRUCT_MANIFEST(projectName)
+  fs.writeFileSync(manifestPath, content, 'utf-8')
+  console.log(`✅ vstruct.json creado en ${manifestPath}`)
+}
+
+function runManifest() {
+  const cwd = process.cwd()
+  const manifestPath = path.join(cwd, 'vstruct.json')
+
+  if (!fs.existsSync(manifestPath)) {
+    console.error('Error: vstruct.json no encontrado. Ejecutá: vstruct init')
+    process.exit(1)
+  }
+
+  const content = fs.readFileSync(manifestPath, 'utf-8')
+  console.log(content)
+}
+
+function showHelp() {
+  console.log(`
+vstruct — CLI para proyectos Vue 3 con estructura predecible
+
+Comandos:
+  vstruct new <nombre>               Crea un nuevo proyecto Vue 3
+  vstruct g <tipo> <nombre>          Genera un archivo en el lugar correcto
+  vstruct analyze                    Valida la estructura del proyecto
+  vstruct init [--force]             Crea vstruct.json en proyecto existente
+  vstruct manifest                   Muestra vstruct.json
+  vstruct help                       Esta ayuda
+
+Tipos de generate (g):
+  c  | component   → src/components/features/<PascalCase>.vue
+  p  | page        → src/pages/<kebab-case>.vue
+  s  | store       → src/stores/<camelCase>.store.ts
+  sv | service     → src/services/<PascalCase>.service.ts
+  co | composable  → src/composables/useXxx.ts
+  l  | layout      → src/layouts/<PascalCase>.vue
+
+Reglas de naming:
+  Componente → PascalCase (UserCard)
+  Página     → kebab-case (user-list)
+  Store      → camelCase (cart, auth)   → se genera use<Name>Store
+  Service    → PascalCase (Product)     → se genera <Name>Service
+  Composable → useXxx (useFetch)       → debe empezar con "use"
+  Layout     → PascalCase (Main, Admin)
+`)
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+export function main(argv = process.argv.slice(2)) {
+  const { args, flags } = parseArgs(argv)
+  const command = args[0]
+  const rest = args.slice(1)
+
+  switch (command) {
+    case 'new':
+      runNew(rest, flags)
+      break
+
+    case 'generate':
+    case 'g':
+      runGenerate(rest)
+      break
+
+    case 'analyze':
+      runAnalyze()
+      break
+
+    case 'init':
+      runInit(rest)
+      break
+
+    case 'manifest':
+      runManifest()
+      break
+
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      showHelp()
+      break
+
+    default:
+      console.error(`Error: comando desconocido "${command}". Ejecutá "vstruct help".`)
+      process.exit(1)
+  }
+}
+
+// Run when called directly
+main()

package/src/commands/generate.js

@@ -0,0 +1,191 @@
+// ---------------------------------------------------------------------------
+// vstruct generate — genera archivos en el lugar correcto automáticamente
+// ---------------------------------------------------------------------------
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import {
+  componentTemplate,
+  pageTemplate,
+  storeTemplate,
+  serviceTemplate,
+  composableTemplate,
+  layoutTemplate,
+} from '../templates/index.js'
+
+// ---------------------------------------------------------------------------
+// Types & aliases
+// ---------------------------------------------------------------------------
+
+const TYPE_ALIASES = {
+  c: 'component',
+  component: 'component',
+  p: 'page',
+  page: 'page',
+  s: 'store',
+  store: 'store',
+  sv: 'service',
+  service: 'service',
+  co: 'composable',
+  composable: 'composable',
+  l: 'layout',
+  layout: 'layout',
+}
+
+export function resolveType(raw) {
+  return TYPE_ALIASES[raw] ?? null
+}
+
+// ---------------------------------------------------------------------------
+// Validators
+// ---------------------------------------------------------------------------
+
+export function isPascalCase(name) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(name)
+}
+
+export function isCamelCase(name) {
+  return /^[a-z][A-Za-z0-9]*$/.test(name)
+}
+
+export function isKebabCase(name) {
+  return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name)
+}
+
+export function isUsePrefixed(name) {
+  return /^use[A-Z]/.test(name)
+}
+
+// ---------------------------------------------------------------------------
+// Path builders
+// ---------------------------------------------------------------------------
+
+function buildComponentPath(cwd, name) {
+  return path.join(cwd, 'src', 'components', 'features', `${name}.vue`)
+}
+
+function buildPagePath(cwd, name) {
+  return path.join(cwd, 'src', 'pages', `${name}.vue`)
+}
+
+function buildStorePath(cwd, name) {
+  return path.join(cwd, 'src', 'stores', `${name}.store.ts`)
+}
+
+function buildServicePath(cwd, name) {
+  return path.join(cwd, 'src', 'services', `${name}.service.ts`)
+}
+
+function buildComposablePath(cwd, name) {
+  const fnName = name.startsWith('use') ? name : 'use' + capitalize(name)
+  return path.join(cwd, 'src', 'composables', `${fnName}.ts`)
+}
+
+function buildLayoutPath(cwd, name) {
+  return path.join(cwd, 'src', 'layouts', `${name}.vue`)
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+// ---------------------------------------------------------------------------
+// Generate
+// ---------------------------------------------------------------------------
+
+export function generate(rawType, name, options = {}) {
+  const cwd = options.cwd ?? process.cwd()
+  const type = resolveType(rawType)
+  const dryRun = options.dryRun ?? false
+
+  if (!type) {
+    throw new GenerateError(
+      `Tipo "${rawType}" desconocido. Válidos: c (component), p (page), s (store), sv (service), co (composable), l (layout)`,
+    )
+  }
+
+  if (!name) {
+    throw new GenerateError(`Falta el nombre para generate ${rawType}`)
+  }
+
+  // Validate naming
+  switch (type) {
+    case 'component':
+      if (!isPascalCase(name))
+        throw new GenerateError(`"${name}" debe ser PascalCase (ej: UserCard)`)
+      break
+    case 'page':
+      if (!isKebabCase(name))
+        throw new GenerateError(`"${name}" debe ser kebab-case (ej: user-list)`)
+      break
+    case 'store':
+      if (!isCamelCase(name))
+        throw new GenerateError(`"${name}" debe ser camelCase singular (ej: cart)`)
+      break
+    case 'service':
+      if (!isPascalCase(name))
+        throw new GenerateError(`"${name}" debe ser PascalCase (ej: Product)`)
+      break
+    case 'composable':
+      if (!isUsePrefixed(name))
+        throw new GenerateError(`"${name}" debe empezar con "use" (ej: useFetch)`)
+      break
+    case 'layout':
+      if (!isPascalCase(name))
+        throw new GenerateError(`"${name}" debe ser PascalCase (ej: Main)`)
+      break
+  }
+
+  // Build path and content
+  let filePath, content
+  switch (type) {
+    case 'component':
+      filePath = buildComponentPath(cwd, name)
+      content = componentTemplate(name)
+      break
+    case 'page':
+      filePath = buildPagePath(cwd, name)
+      content = pageTemplate(name)
+      break
+    case 'store':
+      filePath = buildStorePath(cwd, name)
+      content = storeTemplate(name)
+      break
+    case 'service':
+      filePath = buildServicePath(cwd, name)
+      content = serviceTemplate(name)
+      break
+    case 'composable':
+      filePath = buildComposablePath(cwd, name)
+      content = composableTemplate(name)
+      break
+    case 'layout':
+      filePath = buildLayoutPath(cwd, name)
+      content = layoutTemplate(name)
+      break
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(filePath)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    if (fs.existsSync(filePath)) {
+      throw new GenerateError(`Ya existe: "${filePath}". Elimínalo o elige otro nombre.`)
+    }
+    fs.writeFileSync(filePath, content, 'utf-8')
+  }
+
+  return { filePath, content }
+}
+
+// ---------------------------------------------------------------------------
+// Error
+// ---------------------------------------------------------------------------
+
+export class GenerateError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'GenerateError'
+  }
+}