@ancleto/spec 0.6.36 → 0.6.39

package/README.md

@@ -333,7 +333,7 @@ Funciona en tres piezas que comparten el mismo archivo:
 | `recordRule` | Guarda una regla o restricción permanente. |
 | `recordDecision` | Registra el *por qué* de una decisión. |
 
-Cada entrada tiene un `scope`: `project` (default, entra en `<ProjectMemoryRules>`), `feature` o `task`. El orquestador inyecta los bloques `<ProjectMemoryRules>` y `<ProjectTopology>` en el system prompt de tu agente desde el día cero —incluso sin reglas previas— para que no repita errores ya resueltos.
+Cada entrada tiene un `scope`: `project` (default), `feature` o `task`. Solo las **reglas** activas con scope `project` entran en `<ProjectMemoryRules>`; las **decisiones** con scope `project` se recuperan reactivamente con `searchMemory` y no se inyectan de forma proactiva. El orquestador inyecta los bloques `<ProjectMemoryRules>` y `<ProjectTopology>` en el system prompt de tu agente desde el día cero —incluso sin reglas previas— para que no repita errores ya resueltos.
 
 > El mismo motor se puede consultar a mano desde la terminal: `ancleto memory context --scope project`. El archivo `.ancleto/working-context.md` que lee el orquestador se regenera solo en `init`, `install --project` y `upgrade`.
 

package/package.json

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

package/src/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { existsSync } from 'node:fs'
-import { cp, mkdir, access, writeFile, readFile, readdir, rename } from 'node:fs/promises'
+import { cp, mkdir, access, writeFile, readFile, readdir } from 'node:fs/promises'
 import { spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import { createInterface } from 'node:readline'
@@ -9,6 +9,7 @@ import { join, dirname, resolve, basename, relative } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { homedir, tmpdir } from 'node:os'
 import { createMemoryEngine, createReadonlyMemoryEngine, defaultMemoryDbPath } from '../core/memory/engine.js'
+import { writeWorkingContext } from '../core/memory/working-context.js'
 import { memoryDoctor } from '../core/memory/doctor.js'
 import { serveMemoryMcp } from '../core/memory/mcp-server.js'
 import { writeDiscoveryMap } from '../core/discovery.js'
@@ -775,6 +776,39 @@ async function scaffoldAspec(projectDir) {
   }
 }
 
+const LEGACY_OPENSPEC_DIR = 'openspec'
+const MIGRATION_MARKER = '.migrated-from-openspec'
+
+// "Contenido real" = al menos una entrada bajo changes/ o specs/. Un config.yaml
+// solo (o el scaffold vacio) no cuenta como real: no bloquea la migracion.
+async function hasRealContent(aspecDir) {
+  for (const sub of ['changes', 'specs']) {
+    try {
+      if ((await readdir(join(aspecDir, sub))).length > 0) return true
+    } catch {
+      // subcarpeta inexistente o ilegible: no aporta contenido real
+    }
+  }
+  return false
+}
+
+// Migra la carpeta legacy openspec/ a aspec/ por copia recursiva (no destructiva).
+// Unico dueno del invariante: la invocan init y upgrade antes del scaffold.
+async function migrateLegacyOpenspec(projectDir) {
+  const legacyDir = join(projectDir, LEGACY_OPENSPEC_DIR)
+  if (!(await exists(legacyDir))) return // sin legacy: no-op silencioso
+  const aspecDir = join(projectDir, CHANGES_ROOT)
+  const marker = join(aspecDir, MIGRATION_MARKER)
+  if (await exists(marker)) return // ya migrada: no-op silencioso
+  if (await hasRealContent(aspecDir)) {
+    console.warn('ancleto: aspec/ ya tiene contenido real — no se migro openspec/ (revisar manualmente; openspec/ se conserva)')
+    return
+  }
+  await cp(legacyDir, aspecDir, { recursive: true, force: false })
+  await writeFile(marker, '# Generado por ancleto: esta aspec/ ya fue migrada desde openspec/\n')
+  console.log('ancleto: contenido migrado de openspec/ a aspec/ (openspec/ se conserva como backup)')
+}
+
 function extractLockedBlocks(content) {
   const blocks = new Map()
   const re = /<!--\s*LOCKED:\s*([\w-]+)\s*-->([\s\S]*?)<!--\s*\/LOCKED:\s*\1\s*-->/g
@@ -982,14 +1016,7 @@ async function upgradeCmd(args) {
     console.error("Error: No se encontro .ancletorc. Ejecuta 'ancleto init' primero.")
     process.exit(1)
   }
-  const legacyChanges = join(projectDir, 'openspec')
-  const changesRoot = join(projectDir, CHANGES_ROOT)
-  if ((await exists(legacyChanges)) && !(await exists(changesRoot))) {
-    await rename(legacyChanges, changesRoot)
-    console.log('ancleto: changes migrados de openspec/ a aspec/')
-  } else if ((await exists(legacyChanges)) && (await exists(changesRoot))) {
-    console.warn('ancleto: existen openspec/ y aspec/ — no se migro nada (revisar manualmente)')
-  }
+  await migrateLegacyOpenspec(projectDir)
   const agent = await resolveAgent(args, rc.agent)
   await copyTemplates(projectDir)
   const agentSkillsDir = await installAgentSkills(projectDir, agent)
@@ -1049,6 +1076,12 @@ async function initProject(args) {
   } else {
     agent = await resolveAgent(args, existing?.agent, false)
     tier = tierFlag
+    if (!tier) {
+      // Paridad con install: sin flag se respeta el tier guardado. Sin esto un
+      // re-init pelado re-copiaba los agents de origen y perdia los modelos aplicados.
+      const stored = (await exists(tierFile)) ? (await readFile(tierFile, 'utf8')).trim() : null
+      if (stored && TIERS[stored]) tier = stored
+    }
     if (!language) language = 'auto'
     if (withAzure) azure.enabled = true
   }
@@ -1077,6 +1110,7 @@ async function initProject(args) {
   if (tier) {
     await applyTier(join(projectDir, '.opencode', 'agents'), tier, tierModels(tier, TIERS, gratisModelChoice))
   }
+  await migrateLegacyOpenspec(projectDir)
   await scaffoldAspec(projectDir)
   await refreshWorkingContext(projectDir)
   await registerProject(projectDir, { agent, tier: tier || null })
@@ -1413,16 +1447,11 @@ async function refreshWorkingContext(projectDir, scope = 'project') {
   const dbPath = defaultMemoryDbPath(projectDir)
   if (!(await exists(dbPath))) return null
   const engine = createMemoryEngine(dbPath)
-  let block
   try {
-    block = engine.buildWorkingContext(scope)
+    return writeWorkingContext(engine, projectDir, scope)
   } finally {
     engine.close()
   }
-  const out = join(projectDir, '.ancleto', 'working-context.md')
-  await mkdir(dirname(out), { recursive: true })
-  await writeFile(out, block === null ? '' : block + '\n')
-  return block === null ? null : out
 }
 
 async function memoryContext(flags) {

package/src/core/memory/engine.js

@@ -130,8 +130,8 @@ function buildEngine(db) {
        WHERE memory_fts MATCH ? AND n.status = 'active'`
     const run = (match, loose) => {
       const sql = type
-        ? db.prepare(`${base} AND n.type = ? ORDER BY rank LIMIT ?`)
-        : db.prepare(`${base} ORDER BY rank LIMIT ?`)
+        ? db.prepare(`${base} AND n.type = ? ORDER BY rank, n.rowid LIMIT ?`)
+        : db.prepare(`${base} ORDER BY rank, n.rowid LIMIT ?`)
       // FTS5 no acepta parametros en ORDER BY rank; el prefijo '*' va dentro del MATCH.
       try {
         return type ? sql.all(match, type, lim) : sql.all(match, lim)

package/src/core/memory/mcp-server.js

@@ -1,5 +1,6 @@
 import { createMemoryEngine, defaultMemoryDbPath } from './engine.js'
 import { memoryTools, createMemoryToolHandlers } from './tools.js'
+import { resolveMemoryProjectRoot } from './working-context.js'
 
 const PROTOCOL_VERSION = '2024-11-05'
 const SERVER_INFO = { name: 'ancleto-memory', version: '1.0.0' }
@@ -7,11 +8,12 @@ const SERVER_INFO = { name: 'ancleto-memory', version: '1.0.0' }
 export function createMemoryServer({ dbPath = defaultMemoryDbPath() } = {}) {
   let engine = null
   let handlers = null
+  const projectRoot = resolveMemoryProjectRoot(dbPath)
 
   function toolkit() {
     if (!engine) {
       engine = createMemoryEngine(dbPath)
-      handlers = createMemoryToolHandlers(engine, { source: 'mcp:ancleto-memory' })
+      handlers = createMemoryToolHandlers(engine, { source: 'mcp:ancleto-memory', projectRoot })
     }
     return handlers
   }

package/src/core/memory/tools.js

@@ -1,11 +1,12 @@
 import { createMemoryEngine } from './engine.js'
+import { shouldRefreshWorkingContext, writeWorkingContext } from './working-context.js'
 
 const KEY_DESCRIPTION = 'Clave conceptual estable (ej. "api-error-format"). Reusala para actualizar: la nueva version supersede automaticamente la anterior.'
 
 const SCOPE_SCHEMA = {
   type: 'string',
   enum: ['project', 'feature', 'task'],
-  description: 'Ambito: project (default, entra en <ProjectMemoryRules>), feature o task para algo mas acotado.'
+  description: 'Ambito: project (default; las reglas con scope project entran en <ProjectMemoryRules>, las decisiones se recuperan reactivamente con searchMemory), feature o task para algo mas acotado.'
 }
 
 const SEARCH_SCHEMA = {
@@ -62,10 +63,23 @@ export const memoryTools = [
 ]
 
 export function createMemoryToolHandlers(engine, runtimeContext = {}) {
+  function record(args, type, defaultSource) {
+    const result = engine.recordNode({ ...args, type }, { ...runtimeContext, source: runtimeContext.source || defaultSource })
+    if (runtimeContext.projectRoot && shouldRefreshWorkingContext(result)) {
+      try {
+        writeWorkingContext(engine, runtimeContext.projectRoot)
+      } catch (err) {
+        // stderr: stdout es el canal JSON-RPC del server MCP.
+        console.warn(`ancleto: no se pudo refrescar el working-context: ${err.message}`)
+      }
+    }
+    return result
+  }
+
   return {
     searchMemory: (args) => engine.searchMemory(args),
-    recordRule: (args) => engine.recordNode({ ...args, type: 'rule' }, { ...runtimeContext, source: runtimeContext.source || 'tool:recordRule' }),
-    recordDecision: (args) => engine.recordNode({ ...args, type: 'decision' }, { ...runtimeContext, source: runtimeContext.source || 'tool:recordDecision' })
+    recordRule: (args) => record(args, 'rule', 'tool:recordRule'),
+    recordDecision: (args) => record(args, 'decision', 'tool:recordDecision')
   }
 }
 

package/src/core/memory/working-context.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+// Invariante "memoria activa -> working-context.md": render desde el engine vivo
+// (una sola conexion, sin reabrir la DB) y persistencia del artefacto derivado.
+
+export function workingContextPath(projectRoot) {
+  return join(projectRoot, '.ancleto', 'working-context.md')
+}
+
+// Trigger del refresh sobre el resultado completo de `recordNode` `{ node, superseded }`:
+// (a) contribucion directa: el nodo entrante es rule + project (alimenta el bloque);
+// (b) efecto por supersesion: `memory_key` es identidad transversal (supersede sin filtrar
+//     type/scope), asi que cualquier supersesion pudo retirar del bloque una rule de scope project.
+// El over-refresh (supersesion que no altera el bloque) es intencional: el engine solo expone
+// `{ node, superseded }` y el unico consumidor lee el archivo una vez por sesion.
+export function shouldRefreshWorkingContext(result) {
+  return !!result && ((result.node.type === 'rule' && result.node.scope === 'project') || result.superseded > 0)
+}
+
+// Deriva la raiz del proyecto desde la ubicacion de la DB (no desde el cwd del proceso).
+// Prioriza el primer ancestro con `.ancletorc`; si no hay, usa el candidato derivado de
+// `dbPath` mientras exista el layout `.ancleto/`; si no, no hay raiz (refresh best-effort).
+export function resolveMemoryProjectRoot(dbPath) {
+  if (!dbPath) return null
+  const candidate = dirname(dirname(dbPath))
+  for (let dir = candidate; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, '.ancletorc'))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+  }
+  if (existsSync(join(candidate, '.ancleto'))) return candidate
+  return null
+}
+
+// Render desde el engine vivo con la raiz explicita (topologia + salida) y escritura
+// sincrona del archivo: paridad con `block + '\n'` y `''` cuando el bloque es null.
+// Retorna el path escrito o null si no hay bloque/raiz.
+export function writeWorkingContext(engine, projectRoot, scope = 'project') {
+  if (!projectRoot) return null
+  const block = engine.buildWorkingContext(scope, undefined, projectRoot)
+  const out = workingContextPath(projectRoot)
+  mkdirSync(dirname(out), { recursive: true })
+  writeFileSync(out, block === null ? '' : block + '\n')
+  return block === null ? null : out
+}