@ancleto/spec 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ancleto/spec",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Orquestador SDD liviano con subagentes optimizados para costo/tokens",
   "type": "module",
   "bin": {

package/src/cli/index.js

@@ -10,6 +10,7 @@ import { createMemoryEngine, defaultMemoryDbPath } from '../core/memory/engine.j
 import { memoryDoctor } from '../core/memory/doctor.js'
 import { writeDiscoveryMap } from '../core/discovery.js'
 import { readProjectTier, buildRepomixArgs, tierTokenBudget } from '../core/repomix-tier.js'
+import { showBanner, selectOption, stopBanner } from './ui.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = join(__dirname, '..', '..')
@@ -29,9 +30,9 @@ Uso:
   ancleto install --agent <nombre>    opencode | vscode | antigravity | cursor | roo (pregunta si no esta guardado)
   ancleto update [--project <dir>]    Alias de install (re-instala sobre lo existente)
   ancleto upgrade [--agent <nombre>]  Re-aplica templates (LOCKED) y skills sobre el proyecto actual
-  ancleto init [--with-azure] [--agent <nombre>]
+  ancleto init [--with-azure] [--agent <nombre>] [--tier <nivel>]
                                     Crea .ancletorc en el repositorio actual
-                                    (Azure desactivado por defecto, agente: opencode)
+                                    (interactivo en TTY: banner + menu; Azure desactivado por defecto)
   ancleto discovery --check           Estado del seed (READY/STALE/PARTIAL/MISSING)
   ancleto discovery [--compress] [--include G] [--ignore G] [--token-budget N]
                                    Empaca el repo con Repomix y guarda estado
@@ -201,18 +202,31 @@ function askAgent() {
   })
 }
 
-async function resolveAgent(args, existing) {
-  const ai = args.indexOf('--agent')
-  if (ai >= 0) {
-    const name = args[ai + 1]
-    if (!SUPPORTED_AGENTS.includes(name)) {
-      console.error(`ancleto: agente invalido: ${name} (${SUPPORTED_AGENTS.join('/')})`)
-      process.exit(1)
-    }
-    return name
+function scanAgentFlag(args) {
+  const name = flagValue(args, '--agent')
+  if (!name) return null
+  if (!SUPPORTED_AGENTS.includes(name)) {
+    console.error(`ancleto: agente invalido: ${name} (${SUPPORTED_AGENTS.join('/')})`)
+    process.exit(1)
+  }
+  return name
+}
+
+function scanTierFlag(args) {
+  const t = flagValue(args, '--tier')
+  if (!t) return null
+  if (!TIERS[t]) {
+    console.error(`ancleto: tier invalido: ${t} (normal|minimo|gratis)`)
+    process.exit(1)
   }
+  return t
+}
+
+async function resolveAgent(args, existing, allowAsk = Boolean(process.stdin.isTTY)) {
+  const flag = scanAgentFlag(args)
+  if (flag) return flag
   if (existing && SUPPORTED_AGENTS.includes(existing)) return existing
-  if (process.stdin.isTTY) return askAgent()
+  if (allowAsk) return askAgent()
   return DEFAULT_AGENT
 }
 
@@ -354,12 +368,7 @@ async function install(args) {
   const withMcp = !args.includes('--no-mcp')
   let mcpMap = withMcp ? buildDefaultMcp() : {}
 
-  const ti = args.indexOf('--tier')
-  let tier = ti >= 0 ? args[ti + 1] : null
-  if (tier && !TIERS[tier]) {
-    console.error(`ancleto: tier invalido: ${tier} (normal|minimo|gratis)`)
-    process.exit(1)
-  }
+  let tier = scanTierFlag(args)
 
   if (project) {
     const dir = resolve(project)
@@ -446,17 +455,45 @@ async function upgradeCmd(args) {
 }
 
 async function initProject(args) {
-  const withAzure = args.includes('--with-azure')
   const projectDir = process.cwd()
+  const withAzure = args.includes('--with-azure')
+  const agentFlag = scanAgentFlag(args)
+  const tierFlag = scanTierFlag(args)
   const existing = await readAncletorc(projectDir)
   const azure = existing?.azure ?? { enabled: false }
-  if (withAzure) azure.enabled = true
   const discovery = existing?.discovery ?? { outputDir: 'docs/technical-discovery', exclude: [] }
-  const agent = await resolveAgent(args, existing?.agent)
+  const tierFile = join(projectDir, '.opencode', '.ancleto-tier')
+
+  let agent, tier
+  const isInteractive = Boolean(process.stdout.isTTY) && (!agentFlag || !tierFlag)
+  if (isInteractive) {
+    await showBanner()
+    const agentIdx = Math.max(0, SUPPORTED_AGENTS.indexOf(existing?.agent))
+    const storedTier = (await exists(tierFile)) ? (await readFile(tierFile, 'utf8')).trim() : null
+    const tierIdx = Math.max(0, Object.keys(TIERS).indexOf(TIERS[storedTier] ? storedTier : ''))
+    agent = agentFlag || await selectOption('Agente/IDE', SUPPORTED_AGENTS, agentIdx)
+    tier = tierFlag || await selectOption('Tier de costo', Object.keys(TIERS), tierIdx)
+    if (withAzure) {
+      azure.enabled = true
+    } else {
+      azure.enabled = (await selectOption('Habilitar Azure DevOps', ['No', 'Si'], azure.enabled ? 1 : 0)) === 'Si'
+    }
+    stopBanner()
+  } else {
+    agent = await resolveAgent(args, existing?.agent, false)
+    tier = tierFlag
+    if (withAzure) azure.enabled = true
+  }
+
+  if (tier) {
+    await mkdir(join(projectDir, '.opencode'), { recursive: true })
+    await writeFile(tierFile, tier + '\n')
+  }
+
   const manifest = await writeManifest(projectDir, { azure, discovery, agent })
   await scaffoldOpenSpec(projectDir)
   if (azure.enabled) console.log(AZURE_MCP_NOTICE)
-  console.log(`ancleto: .ancletorc actualizado en ${projectDir} (v${manifest.version})${azure.enabled ? ' (Azure habilitado)' : ' (Azure desactivado)'} (Agente: ${agent})`)
+  console.log(`ancleto: .ancletorc actualizado en ${projectDir} (v${manifest.version})${azure.enabled ? ' (Azure habilitado)' : ' (Azure desactivado)'} (Agente: ${agent})${tier ? ` (Tier: ${tier})` : ''}`)
 }
 
 const DEFAULT_IGNORES = ['node_modules', '.git', 'dist']

package/src/cli/ui.js

@@ -0,0 +1,181 @@
+import { setTimeout as sleep } from 'node:timers/promises'
+
+const CYAN = '\x1b[36m'
+const BOLD = '\x1b[1m'
+const RESET = '\x1b[0m'
+
+const CUP = [
+  '             █████████████████████████████████',
+  '            █████████████████████████████████████',
+  '            ██                             ██   ███',
+  '             ██                           ██     ██',
+  '             ███                         ███    ███',
+  '              ███                       █████████',
+  '                ███                   ███',
+  '          ██████████████████████████████████████',
+  '          ███████                      █████████',
+  '            ██████████████████████████████████',
+  '              ██████████████████████████████'
+]
+
+const LOGO = [
+  ' ██████  ██    ██  ██████ ██      ███████ ████████  ██████ ',
+  '██    ██ ███   ██ ██      ██      ██         ██    ██    ██',
+  '████████ ██ █  ██ ██      ██      █████      ██    ██    ██',
+  '██    ██ ██  █ ██ ██      ██      ██         ██    ██    ██',
+  '██    ██ ██   ███  ██████ ███████ ███████    ██     ██████ '
+]
+
+const ART = [...CUP, '', ...LOGO, '']
+const TEXT_START = CUP.length + 1
+
+const CUP_PALETTE = ['\x1b[38;5;94m', '\x1b[38;5;130m', '\x1b[38;5;172m', '\x1b[38;5;208m', '\x1b[38;5;214m', '\x1b[38;5;220m', '\x1b[38;5;230m']
+const TEXT_PALETTE = ['\x1b[38;5;27m', '\x1b[38;5;33m', '\x1b[38;5;45m', '\x1b[38;5;51m', '\x1b[38;5;201m']
+
+let activeBanner = null
+
+function waveColorIndex(x, y, t, size) {
+  const v = Math.sin((x + y) * 0.15 + t)
+  return Math.round(((v + 1) / 2) * (size - 1))
+}
+
+function renderWaveLine(line, y, t, palette) {
+  let out = ''
+  let last = -1
+  for (let x = 0; x < line.length; x++) {
+    const ch = line[x]
+    if (ch === ' ') {
+      out += ' '
+      last = -1
+      continue
+    }
+    const idx = waveColorIndex(x, y, t, palette.length)
+    if (idx !== last) {
+      out += palette[idx]
+      last = idx
+    }
+    out += ch
+  }
+  return out + RESET
+}
+
+export function stopBanner() {
+  if (activeBanner) activeBanner.stop()
+}
+
+export function showBanner(delay = 80, duration = 20000) {
+  const out = process.stdout
+
+  if (!out.isTTY) {
+    for (const line of ART) out.write(line ? `${CYAN}${line}${RESET}\n` : '\n')
+    out.write('\n')
+    return
+  }
+
+  stopBanner()
+  const state = { below: 0, stopped: false, hidden: false }
+  const restoreCursor = () => {
+    if (state.hidden) {
+      out.write('\x1b[?25h')
+      state.hidden = false
+    }
+  }
+  const stop = () => {
+    if (state.stopped) return
+    state.stopped = true
+    process.removeListener('SIGINT', onSigint)
+    restoreCursor()
+    if (activeBanner === state) activeBanner = null
+  }
+  const onSigint = () => {
+    stop()
+    process.exit(0)
+  }
+  state.stop = stop
+  activeBanner = state
+
+  ;(async () => {
+    out.write('\x1b[?25l')
+    state.hidden = true
+    process.once('SIGINT', onSigint)
+    const deadline = Date.now() + duration
+    let f = 0
+    try {
+      while (!state.stopped && Date.now() < deadline) {
+        if (f > 0) out.write(`\x1b[${ART.length + state.below}A`)
+        for (let y = 0; y < ART.length; y++) {
+          const line = ART[y]
+          const palette = y >= TEXT_START ? TEXT_PALETTE : CUP_PALETTE
+          out.write(`\x1b[2K${line ? renderWaveLine(line, y, f * 0.6, palette) : ''}\n`)
+        }
+        if (state.below > 0) out.write(`\x1b[${state.below}B`)
+        if (state.stopped) break
+        f++
+        await sleep(delay)
+      }
+    } finally {
+      stop()
+    }
+  })()
+}
+
+export async function selectOption(message, options, initial = 0) {
+  const stdin = process.stdin
+  const out = process.stdout
+  const start = Math.min(Math.max(Number(initial) || 0, 0), options.length - 1)
+  if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') return options[start]
+
+  let index = start
+  let rendered = 0
+  const draw = () => {
+    if (rendered > 0) out.write(`\x1b[${rendered}A`)
+    let buf = ''
+    for (let i = 0; i < options.length; i++) {
+      const pointer = i === index ? `${CYAN}❯${RESET}` : ' '
+      const label = i === index ? `${BOLD}${options[i]}${RESET}` : options[i]
+      buf += `\x1b[2K  ${pointer} ${label}\n`
+    }
+    out.write(buf)
+    rendered = options.length
+  }
+
+  const SIGINT = Symbol('SIGINT')
+  let resolveKey
+  const key = new Promise((resolve) => { resolveKey = resolve })
+  const onData = (chunk) => {
+    const s = chunk.toString('utf8')
+    if (s === '\u0003') {
+      stopBanner()
+      resolveKey(SIGINT)
+    } else if (s === '\u001b[A') {
+      index = (index - 1 + options.length) % options.length
+      draw()
+    } else if (s === '\u001b[B') {
+      index = (index + 1) % options.length
+      draw()
+    } else if (s === '\r' || s === '\n') {
+      resolveKey(options[index])
+    }
+  }
+
+  let result
+  try {
+    out.write(`${CYAN}?${RESET} ${BOLD}${message}${RESET}\n`)
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.on('data', onData)
+    draw()
+    if (activeBanner) activeBanner.below += 1 + options.length
+    result = await key
+    out.write('\n')
+    if (activeBanner) activeBanner.below += 1
+  } catch {
+    result = undefined
+  } finally {
+    stdin.removeListener('data', onData)
+    try { stdin.setRawMode(false) } catch {}
+    stdin.pause()
+  }
+  if (result === SIGINT) process.exit(0)
+  return result === undefined ? options[start] : result
+}