@vobs/cli 0.3.0 → 1.2.0

package/src/repl.ts

@@ -0,0 +1,140 @@
+import { createInterface } from 'node:readline/promises'
+import { stdin, stdout } from 'node:process'
+import pc from 'picocolors'
+import { showLogo, showBanner } from './banner.js'
+import { initCommand } from './commands/init.js'
+import { generateCommand } from './commands/generate.js'
+import { addCommand } from './commands/add.js'
+
+/**
+ * Interactive REPL shell. Runs `vobs` with no arguments and stays in CLI
+ * mode accepting repeated commands until the user types `exit` / `quit`
+ * or presses Ctrl+C / Ctrl+D.
+ */
+export async function startRepl(): Promise<void> {
+  showLogo()
+
+  const rl = createInterface({
+    input: stdin,
+    output: stdout,
+    prompt: `  ${pc.magenta('❯')} `,
+    terminal: true
+  })
+
+  rl.prompt()
+
+  for await (const rawLine of rl) {
+    const line = rawLine.trim()
+
+    if (!line) {
+      rl.prompt()
+      continue
+    }
+
+    // Split into args, honoring simple double quotes
+    const args = splitArgs(line)
+
+    try {
+      await dispatch(args)
+    } catch (err) {
+      console.error(`  ${pc.red('✖')} ${err instanceof Error ? err.message : String(err)}`)
+    }
+
+    rl.prompt()
+  }
+}
+
+type Command = (args: string[]) => Promise<void>
+
+/** Internal command table for the REPL */
+const TABLE: Record<string, { cmd: Command; help: string }> = {
+  help: {
+    cmd: async () => {
+      console.log(`  ${pc.bold('Available commands:')}`)
+      console.log(`    ${pc.dim('exit|quit')}      Leave the interactive CLI`)
+      console.log(`    ${pc.dim('clear')}          Clear the screen`)
+      console.log(`    ${pc.dim('logo')}           Re-print the banner`)
+      console.log(`    ${pc.dim('version')}        Show version`)
+      console.log(`    ${pc.dim('init <name>')}    Create a new vobs project`)
+      console.log(`    ${pc.dim('generate <name>')} Generate a component/page`)
+      console.log(`    ${pc.dim('add <package>')}   Add a package`)
+      console.log(`    ${pc.dim('dev|build')}       Use \`vobs dev\` / \`vobs build\` in a terminal`)
+    },
+    help: ''
+  },
+  logo: { cmd: async () => showLogo(), help: '' },
+  version: { cmd: async () => showBanner(), help: '' },
+  clear: {
+    cmd: async () => {
+      process.stdout.write('\x1Bc')
+    },
+    help: ''
+  },
+  exit: { cmd: async () => process.exit(0), help: '' },
+  quit: { cmd: async () => process.exit(0), help: '' },
+  init: {
+    cmd: async (args) => {
+      await initCommand({
+        name: args[0],
+        targetDir: undefined,
+        packageManager: undefined,
+        typescript: true,
+        git: true
+      })
+    },
+    help: ''
+  },
+  generate: {
+    cmd: async (args) => {
+      await generateCommand({
+        name: args[0],
+        type: undefined,
+        targetDir: undefined
+      })
+    },
+    help: ''
+  },
+  g: {
+    cmd: async (args) => {
+      await generateCommand({
+        name: args[0],
+        type: undefined,
+        targetDir: undefined
+      })
+    },
+    help: ''
+  },
+  add: {
+    cmd: async (args) => {
+      await addCommand({ package: args[0], dev: args.includes('-D') || args.includes('--dev') })
+    },
+    help: ''
+  }
+}
+
+/** Dispatch a parsed command line to the internal table */
+async function dispatch(args: string[]): Promise<void> {
+  const name = args[0]
+  const rest = args.slice(1)
+
+  if (!name) return
+
+  const entry = TABLE[name]
+  if (entry) {
+    await entry.cmd(rest)
+    return
+  }
+
+  console.log(`  ${pc.yellow('⚠')} Unknown command: ${pc.bold(String(name))}. Type ${pc.cyan('help')} to see options.`)
+}
+
+/** Minimal tokenizer supporting double-quoted arguments */
+function splitArgs(line: string): string[] {
+  const out: string[] = []
+  const re = /[^\s"']+|"([^"]*)"|'([^']*)'/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(line)) !== null) {
+    out.push(m[1] ?? m[2] ?? m[0])
+  }
+  return out
+}

package/src/start.ts

@@ -0,0 +1,20 @@
+import { createCLI } from './cli.js'
+import { showBanner } from './banner.js'
+import { startRepl } from './repl.js'
+
+/** Entry point: decides between interactive REPL and single-shot commands */
+export async function start(args: string[]): Promise<void> {
+  // No args (or explicit `cli`) → launch the interactive REPL
+  if (args.length === 0 || args[0] === 'cli') {
+    await startRepl()
+    return
+  }
+
+  if (args.includes('--version') || args.includes('-V')) {
+    showBanner()
+    return
+  }
+
+  // Let cac read the full process.argv so single-shot commands dispatch correctly
+  createCLI().parse()
+}

package/src/templates/basic/.gitignore.hbs

@@ -0,0 +1,4 @@
+node_modules
+dist
+*.local
+.DS_Store

package/src/templates/basic/index.html.hbs

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{name}}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/src/templates/basic/package.json.hbs

@@ -0,0 +1,25 @@
+{
+  "name": "{{packageName}}",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "vobs dev",
+    "build": "vobs build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@vobs/dom": "^{{vobsVersion}}",
+    "@vobs/ui": "^{{vobsVersion}}",
+    "@vobs/router": "^{{vobsVersion}}",
+    "@vobs/i18n": "^{{vobsVersion}}",
+    "@vobs/notification": "^{{vobsVersion}}"
+  },
+  "devDependencies": {
+    "@vobs/cli": "^{{vobsVersion}}",
+    "@vobs/vite-plugin": "^{{vobsVersion}}",
+    "@vobs/tailwind": "^{{vobsVersion}}",
+    "vite": "^7.0.0",
+    "typescript": "^5.6.0"
+  }
+}

package/src/templates/basic/src/App.tsx.hbs

@@ -0,0 +1,8 @@
+export default function App() {
+  return (
+    <div>
+      <h1>Welcome to {{name}}</h1>
+      <p>Built with Vobs Framework</p>
+    </div>
+  )
+}

package/src/templates/basic/src/app.css.hbs

@@ -0,0 +1,32 @@
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  line-height: 1.6;
+  color: #1e2233;
+  background: #f8f9fb;
+}
+
+#app {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+}
+
+h1 {
+  font-size: 2.5rem;
+  margin-bottom: 0.5rem;
+  color: #6366f1;
+}
+
+p {
+  font-size: 1.125rem;
+  color: #6b7280;
+}

package/src/templates/basic/src/main.ts.hbs

@@ -0,0 +1,20 @@
+import { createVobs } from '@vobs/dom'
+import { i18nPlugin } from '@vobs/i18n'
+import { notificationPlugin } from '@vobs/notification'
+import { routerPlugin } from '@vobs/router'
+import { createBrowserHistory } from '@vobs/router/history'
+import App from './App.js'
+import './app.css'
+
+const app = createVobs({
+  render: App,
+  plugins: [
+    i18nPlugin(),
+    notificationPlugin(),
+    routerPlugin({
+      history: createBrowserHistory('/'),
+    }),
+  ],
+})
+
+app.mount('#app')

package/src/templates/basic/tsconfig.json.hbs

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "preserve",
+    "jsxImportSource": "@vobs/dom",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/src/templates/basic/vite.config.ts.hbs

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite'
+import { vobsPlugin } from '@vobs/vite-plugin'
+import { vobsTailwind } from '@vobs/tailwind'
+
+export default defineConfig({
+  plugins: [
+    vobsPlugin(),
+    vobsTailwind()
+  ]
+})

package/src/templates/component.hbs

@@ -0,0 +1,7 @@
+export default function {{name}}() {
+  return (
+    <div class="{{kebabName}}">
+      <h2>{{name}} Component</h2>
+    </div>
+  )
+}

package/src/templates/page.hbs

@@ -0,0 +1,7 @@
+export default function {{name}}() {
+  return (
+    <div>
+      <h1>{{name}}</h1>
+    </div>
+  )
+}

package/src/types.ts

@@ -0,0 +1,78 @@
+export interface InitOptions {
+  /** Project name */
+  name: string
+  /** Target directory */
+  targetDir: string
+  /** Package manager to use */
+  packageManager?: 'pnpm' | 'npm' | 'yarn'
+  /** Use TypeScript */
+  typescript?: boolean
+  /** Initialize git repo */
+  git?: boolean
+}
+
+export interface GenerateOptions {
+  /** Generator type: component | page */
+  type: 'component' | 'page'
+  /** Name of the generated artifact */
+  name: string
+  /** Target directory (defaults to src/components/ or src/pages/) */
+  targetDir?: string
+}
+
+export interface DevOptions {
+  /** Vite config file path */
+  config?: string
+  /** Port to listen on */
+  port?: number
+  /** Open browser on start */
+  open?: boolean
+}
+
+export interface BuildOptions {
+  /** Vite config file path */
+  config?: string
+  /** Output directory */
+  outDir?: string
+  /** Mode (production | development) */
+  mode?: string
+}
+
+export interface AddOptions {
+  /** Package name to add */
+  package: string
+  /** Save as dev dependency */
+  dev?: boolean
+}
+
+export interface TemplateContext {
+  /** Project name */
+  name: string
+  /** Package name (kebab-case) */
+  packageName: string
+  /** Use TypeScript */
+  typescript: boolean
+  /** @vobs/* version to use */
+  vobsVersion: string
+}
+
+export interface ComponentTemplateContext {
+  /** Component name (PascalCase) */
+  name: string
+  /** Component name (kebab-case) */
+  kebabName: string
+}
+
+export interface PageTemplateContext {
+  /** Page name (PascalCase) */
+  name: string
+  /** Route path */
+  path: string
+}
+
+export type LoggerLevel = 'info' | 'success' | 'warn' | 'error'
+
+export interface CLIOptions {
+  /** Enable debug output */
+  debug?: boolean
+}

package/src/utils/file.ts

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import Handlebars from 'handlebars'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const TEMPLATES_ROOT = resolve(__dirname, '..', 'templates')
+
+/** Get the absolute path to the templates directory */
+export function getTemplatesDir(): string {
+  return TEMPLATES_ROOT
+}
+
+/** Read a template file and compile it with Handlebars */
+export function renderTemplate(
+  templatePath: string,
+  context: Record<string, unknown>
+): string {
+  const source = readFileSync(templatePath, 'utf-8')
+  const template = Handlebars.compile(source)
+  return template(context)
+}
+
+/** Write a file, creating parent directories if needed */
+export function writeFile(dir: string, filename: string, content: string): void {
+  const filePath = resolve(dir, filename)
+  mkdirSync(dirname(filePath), { recursive: true })
+  writeFileSync(filePath, content, 'utf-8')
+}
+
+/** Ensure a directory exists */
+export function ensureDir(dir: string): void {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+}
+
+/** Check if a path exists */
+export function pathExists(path: string): boolean {
+  return existsSync(path)
+}
+
+/** Copy a template directory recursively, rendering each .hbs file */
+async function copyDirRecursive(srcDir: string, destDir: string, context: Record<string, unknown>): Promise<void> {
+  const { readdirSync } = await import('node:fs')
+  const { join } = await import('node:path')
+
+  const entries = readdirSync(srcDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name)
+    const isHbs = entry.name.endsWith('.hbs')
+    const destName = isHbs ? entry.name.slice(0, -4) : entry.name
+    const destPath = join(destDir, destName)
+
+    if (entry.isDirectory()) {
+      ensureDir(destPath)
+      await copyDirRecursive(srcPath, destPath, context)
+    } else if (isHbs) {
+      const content = renderTemplate(srcPath, context)
+      writeFile(destDir, destName, content)
+    } else {
+      const content = readFileSync(srcPath, 'utf-8')
+      writeFile(destDir, destName, content)
+    }
+  }
+}
+
+/** Scaffold a project from the basic template */
+export async function scaffoldProject(
+  targetDir: string,
+  context: Record<string, unknown>
+): Promise<void> {
+  const templateDir = resolve(TEMPLATES_ROOT, 'basic')
+  ensureDir(targetDir)
+  await copyDirRecursive(templateDir, targetDir, context)
+}

package/src/utils/logger.ts

@@ -0,0 +1,27 @@
+import pc from 'picocolors'
+
+function timestamp(): string {
+  return pc.dim(`[${new Date().toLocaleTimeString()}]`)
+}
+
+export function info(msg: string): void {
+  console.log(`${timestamp()} ${pc.cyan('ℹ')} ${msg}`)
+}
+
+export function success(msg: string): void {
+  console.log(`${timestamp()} ${pc.green('✔')} ${msg}`)
+}
+
+export function warn(msg: string): void {
+  console.log(`${timestamp()} ${pc.yellow('⚠')} ${msg}`)
+}
+
+export function error(msg: string): void {
+  console.error(`${timestamp()} ${pc.red('✖')} ${msg}`)
+}
+
+export function step(msg: string): void {
+  console.log(`\n  ${pc.bold(pc.cyan(msg))}`)
+}
+
+export const logger = { info, success, warn, error, step }

package/src/utils/pm.ts

@@ -0,0 +1,42 @@
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { execSync } from 'node:child_process'
+
+export type PackageManager = 'pnpm' | 'npm' | 'yarn'
+
+/** Detect the package manager to use */
+export function detectPackageManager(targetDir?: string): PackageManager {
+  // Check if a specific package manager is locked
+  if (targetDir) {
+    if (existsSync(resolve(targetDir, 'pnpm-lock.yaml'))) return 'pnpm'
+    if (existsSync(resolve(targetDir, 'yarn.lock'))) return 'yarn'
+    if (existsSync(resolve(targetDir, 'package-lock.json'))) return 'npm'
+  }
+
+  // Check for global preference
+  const userAgent = process.env.npm_config_user_agent || ''
+  if (userAgent.startsWith('pnpm')) return 'pnpm'
+  if (userAgent.startsWith('yarn')) return 'yarn'
+  if (userAgent.startsWith('npm')) return 'npm'
+
+  // Default to pnpm
+  return 'pnpm'
+}
+
+/** Install dependencies in a directory */
+export function installDependencies(targetDir: string, pm: PackageManager): void {
+  const cmd = pm === 'yarn' ? 'yarn' : `${pm} install`
+  execSync(cmd, { cwd: targetDir, stdio: 'inherit' })
+}
+
+/** Add a package as a dependency */
+export function addPackage(targetDir: string, pm: PackageManager, pkg: string, dev: boolean): void {
+  const installFlag = dev ? '-D' : ''
+  const cmd = pm === 'npm'
+    ? `npm install ${installFlag} ${pkg}`
+    : pm === 'yarn'
+      ? `yarn add ${installFlag} ${pkg}`
+      : `pnpm add ${installFlag} ${pkg}`
+
+  execSync(cmd, { cwd: targetDir, stdio: 'inherit' })
+}

package/dist/ai-server.d.ts

@@ -1,11 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/cli
- */
-export interface VobsAiServerStreams {
-    readonly input: AsyncIterable<string>;
-    readonly stdout: Pick<NodeJS.WriteStream, 'write'>;
-    readonly stderr?: Pick<NodeJS.WriteStream, 'write'>;
-}
-/** Serve the read-only vobs AI tools over line-delimited JSON-RPC on stdio. */
-export declare function runVobsAiServer(streams: VobsAiServerStreams): Promise<void>;