@nitra/cursor 4.1.1 → 5.0.0

package/scripts/graph/index.mjs

@@ -1,115 +0,0 @@
-/**
- * `n-cursor graph` — CLI entry point для нової graph-архітектури.
- * Реалізує команди з docs/думка.MD (фінальний дизайн 2026-06-07).
- */
-
-/**
- * @param {string[]} argv процесні аргументи після 'graph'
- * @returns {Promise<number>} exit code
- */
-export async function runGraphCli(argv) {
-  const [cmd, ...rest] = argv
-
-  const hasJson = rest.includes('--json')
-  const cleanRest = rest.filter(a => a !== '--json')
-
-  switch (cmd) {
-    case 'scan':
-      return (await import('./scan.mjs')).runScan(cleanRest, { json: hasJson })
-
-    case 'status': {
-      const path = cleanRest[0]
-      return (await import('./status.mjs')).runStatus(path, { json: hasJson })
-    }
-
-    case 'setup':
-      return (await import('./setup.mjs')).runSetup(cleanRest)
-
-    case 'init': {
-      const [name, ...initRest] = cleanRest
-      return (await import('./init.mjs')).runInit(name, parseFlags(initRest))
-    }
-
-    case 'plan': {
-      const flags = parseFlags(cleanRest)
-      return (await import('./plan.mjs')).runPlan(flags.path, flags)
-    }
-
-    case 'run': {
-      const flags = parseFlags(cleanRest)
-      return (await import('./run.mjs')).runRun(flags.path, flags)
-    }
-
-    case 'kill': {
-      const path = cleanRest[0]
-      return (await import('./kill.mjs')).runKill(path)
-    }
-
-    case 'invalidate': {
-      const flags = parseFlags(cleanRest)
-      return (await import('./invalidate.mjs')).runInvalidate(flags.path, flags)
-    }
-
-    case 'done':
-    case 'audit':
-    case 'failed':
-    case 'spawn': {
-      const path = cleanRest[0]
-      return (await import('./signals.mjs')).runSignal(cmd, path, parseFlags(cleanRest.slice(1)))
-    }
-
-    case undefined:
-    case '--help':
-    case 'help':
-      printHelp()
-      return 0
-
-    default:
-      console.error(`Unknown graph command: ${cmd}`)
-      printHelp()
-      return 1
-  }
-}
-
-/** @param {string[]} args @returns {Record<string, string | boolean>} */
-function parseFlags(args) {
-  /** @type {Record<string, string | boolean>} */
-  const flags = {}
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i]
-    if (a.startsWith('--')) {
-      const key = a.slice(2)
-      const next = args[i + 1]
-      if (next && !next.startsWith('--')) {
-        flags[key] = next
-        i++
-      } else {
-        flags[key] = true
-      }
-    } else if (!flags.path) {
-      flags.path = a
-    }
-  }
-  return flags
-}
-
-function printHelp() {
-  console.log(`n-cursor graph <command> [options]
-
-Commands:
-  setup                              Initialize project (.n-cursor.json, hooks)
-  init <name> [--task "..."]         Create task.md for a new node
-  plan [<path>] [--mode agent]       Stage 1: spec + decompose → plan_NNN.md
-  status [<path>] [--json]           Show graph or node state
-  scan [--json]                      Full scan; exit 1 if any failed nodes
-  run [<path>] [--actor a] [--auto]  Execute node or run orchestrator
-  kill <path>                        Kill worktrees + cascade invalidate
-  invalidate <path> [--no-cascade]   Mark node as invalidated
-
-Agent signals (called from within worktree):
-  done <path>                        Signal success → merge
-  audit <path>                       Request audit → pending-audit_NNN.md
-  failed <path>                      Signal failure
-  spawn <path>                       Register composite subgraph
-`)
-}

package/scripts/graph/lib/config.mjs

@@ -1,62 +0,0 @@
-/**
- * Завантаження `.n-cursor.json` + per-node `.n-cursor-override.json`.
- * Всі поля опціональні — повертає merge із дефолтами.
- */
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-/** @typedef {{ tasks_dir: string, worktrees_dir: string, warn_worktrees_above: number, max_worktrees: number, default_budget_sec: number, budget_hard_sec_multiplier: number, progress_timeout_sec: number, stderr_lines: number, claude_model: string, audit_model: string, model_map: Record<string,string>, stale_worktree_min: number, system_prompt: string }} GraphConfig */
-
-/** @type {GraphConfig} */
-const DEFAULTS = {
-  tasks_dir: './tasks',
-  worktrees_dir: './.worktrees',
-  warn_worktrees_above: 4,
-  max_worktrees: 8,
-  default_budget_sec: 1800,
-  budget_hard_sec_multiplier: 3,
-  progress_timeout_sec: 300,
-  stderr_lines: 50,
-  claude_model: 'claude-sonnet-4-6',
-  audit_model: 'claude-haiku-4-5-20251001',
-  model_map: {
-    MIM: 'claude-haiku-4-5-20251001',
-    AVG: 'claude-sonnet-4-6',
-    MAX: 'claude-opus-4-8',
-  },
-  stale_worktree_min: 30,
-  system_prompt: '.n-cursor/system-prompt.md',
-}
-
-/**
- * Читає `.n-cursor.json` з root та мержить із дефолтами.
- * @param {string} root
- * @returns {GraphConfig}
- */
-export function loadConfig(root) {
-  const path = join(root, '.n-cursor.json')
-  if (!existsSync(path)) return { ...DEFAULTS }
-  try {
-    const raw = JSON.parse(readFileSync(path, 'utf8'))
-    return { ...DEFAULTS, ...raw, model_map: { ...DEFAULTS.model_map, ...raw.model_map } }
-  } catch {
-    return { ...DEFAULTS }
-  }
-}
-
-/**
- * Читає per-node `.n-cursor-override.json` та мержить із базовим конфігом.
- * @param {GraphConfig} base
- * @param {string} nodePath абсолютний шлях до директорії вузла
- * @returns {GraphConfig}
- */
-export function loadNodeOverride(base, nodePath) {
-  const path = join(nodePath, '.n-cursor-override.json')
-  if (!existsSync(path)) return base
-  try {
-    const raw = JSON.parse(readFileSync(path, 'utf8'))
-    return { ...base, ...raw }
-  } catch {
-    return base
-  }
-}

package/scripts/graph/lib/dag.mjs

@@ -1,161 +0,0 @@
-/**
- * Побудова DAG з файлової структури `tasks/`.
- * Читає task.md кожного вузла (один раз), будує граф в пам'яті.
- * Deps satisfaction вираховується пакетно — не per-node.
- */
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
-import { join, relative } from 'node:path'
-
-import { parseFrontmatter } from './frontmatter.mjs'
-import { deriveAtomicState, deriveCompositeState } from './state.mjs'
-
-/**
- * @typedef {{
- *   id: string,
- *   path: string,
- *   parentId: string | null,
- *   deps: string[],
- *   mode: string,
- *   executor: { type: string, model_tier: string, skills: string[] },
- *   budget_sec: number,
- *   isComposite: boolean,
- *   children: string[],
- *   state: import('./state.mjs').NodeState,
- *   meta: Record<string, unknown>
- * }} GraphNode
- */
-
-/**
- * Сканує tasks_dir і будує повний DAG.
- * @param {string} tasksDir абсолютний шлях
- * @param {string} [worktreesDir]
- * @returns {Map<string, GraphNode>}
- */
-export function buildDag(tasksDir, worktreesDir = '') {
-  /** @type {Map<string, GraphNode>} */
-  const nodes = new Map()
-
-  // 1. Collect all nodes
-  collectNodes(tasksDir, tasksDir, null, nodes)
-
-  // 2. Resolve parent-child relationships
-  for (const node of nodes.values()) {
-    if (node.parentId) {
-      const parent = nodes.get(node.parentId)
-      if (parent && !parent.children.includes(node.id)) {
-        parent.children.push(node.id)
-        parent.isComposite = true
-      }
-    }
-  }
-
-  // 3. Derive states (bottom-up)
-  const resolvedIds = new Set()
-  deriveStatesBottomUp(tasksDir, nodes, resolvedIds, worktreesDir)
-
-  return nodes
-}
-
-/**
- * @param {string} dir поточна директорія
- * @param {string} tasksDir корінь tasks
- * @param {string | null} parentId
- * @param {Map<string, GraphNode>} nodes
- */
-function collectNodes(dir, tasksDir, parentId, nodes) {
-  const taskFile = join(dir, 'task.md')
-  if (!existsSync(taskFile)) return
-
-  const id = relative(tasksDir, dir).replace(/\\/gu, '/')
-  if (!id) return
-
-  const { data } = parseFrontmatter(readSafe(taskFile))
-
-  /** @type {string[]} */
-  const deps = Array.isArray(data.deps) ? data.deps.map(String) : []
-
-  const executor = typeof data.executor === 'object' && data.executor !== null
-    ? data.executor
-    : { type: 'agent', model_tier: 'AVG', skills: [] }
-
-  /** @type {GraphNode} */
-  const node = {
-    id,
-    path: dir,
-    parentId,
-    deps,
-    mode: String(data.mode ?? 'human'),
-    executor: {
-      type: String(executor.type ?? 'agent'),
-      model_tier: String(executor.model_tier ?? 'AVG'),
-      skills: Array.isArray(executor.skills) ? executor.skills : [],
-    },
-    budget_sec: Number(data.budget_sec ?? 1800),
-    isComposite: false,
-    children: [],
-    state: 'needs-plan',
-    meta: data,
-  }
-
-  nodes.set(id, node)
-
-  // Scan children
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory()) {
-        collectNodes(join(dir, entry.name), tasksDir, id, nodes)
-      }
-    }
-  } catch { /* skip */ }
-}
-
-/**
- * Обходить граф знизу вверх (листи → корінь) і деривує стани.
- * @param {string} tasksDir
- * @param {Map<string, GraphNode>} nodes
- * @param {Set<string>} resolvedIds
- * @param {string} worktreesDir
- */
-function deriveStatesBottomUp(tasksDir, nodes, resolvedIds, worktreesDir) {
-  // Topological sort (Kahn's algorithm by deps within siblings)
-  const visited = new Set()
-  const order = []
-
-  /** @param {string} id */
-  function visit(id) {
-    if (visited.has(id)) return
-    visited.add(id)
-    const node = nodes.get(id)
-    if (!node) return
-    for (const child of node.children) visit(child)
-    order.push(id)
-  }
-
-  for (const id of nodes.keys()) visit(id)
-
-  // Process leaves first (order is reversed)
-  for (const id of order) {
-    const node = nodes.get(id)
-    if (!node) continue
-
-    if (node.isComposite) {
-      const childStates = node.children.map(cid => nodes.get(cid)?.state ?? 'needs-plan')
-      node.state = deriveCompositeState(node.path, childStates)
-    } else {
-      const depsResolved = node.deps.every(dep => {
-        // Deps are sibling IDs — resolve relative to parent
-        const siblingId = node.parentId ? `${node.parentId}/${dep}` : dep
-        const sibling = nodes.get(siblingId) ?? nodes.get(dep)
-        return sibling?.state === 'resolved'
-      })
-      node.state = deriveAtomicState(node.path, { depsResolved })
-    }
-
-    if (node.state === 'resolved') resolvedIds.add(id)
-  }
-}
-
-/** @param {string} path @returns {string} */
-function readSafe(path) {
-  try { return readFileSync(path, 'utf8') } catch { return '' }
-}

package/scripts/graph/lib/frontmatter.mjs

@@ -1,70 +0,0 @@
-/**
- * Мінімальний YAML-фронтматер парсер для Markdown-файлів.
- * Підтримує: рядки, числа, boolean, масиви (flow і block), вкладені об'єкти (один рівень).
- */
-
-const FM_RE = /^---\r?\n([\s\S]*?)\r?\n---/u
-
-/**
- * @param {string} content вміст md-файлу
- * @returns {{ data: Record<string, unknown>, body: string }}
- */
-export function parseFrontmatter(content) {
-  const m = FM_RE.exec(content)
-  if (!m) return { data: {}, body: content }
-  const raw = m[1]
-  const body = content.slice(m[0].length).trimStart()
-  return { data: parseYamlBlock(raw), body }
-}
-
-/**
- * @param {string} block YAML-блок між ---
- * @returns {Record<string, unknown>}
- */
-function parseYamlBlock(block) {
-  const result = {}
-  const lines = block.split(/\r?\n/u)
-  let i = 0
-
-  while (i < lines.length) {
-    const line = lines[i]
-    const keyMatch = /^([a-z_][a-z0-9_]*):\s*(.*)/iu.exec(line)
-    if (!keyMatch) { i++; continue }
-
-    const key = keyMatch[1]
-    const rest = keyMatch[2].trim()
-
-    if (rest === '' || rest === '|' || rest === '>') {
-      // block scalar або об'єкт — збираємо indented рядки
-      const children = []
-      i++
-      while (i < lines.length && /^\s+/u.test(lines[i])) {
-        children.push(lines[i])
-        i++
-      }
-      if (children.length > 0 && /^\s+-\s+/u.test(children[0])) {
-        result[key] = children.map(l => l.replace(/^\s+-\s+/u, '').trim())
-      } else {
-        result[key] = parseYamlBlock(children.map(l => l.replace(/^\s{2}/u, '')).join('\n'))
-      }
-    } else if (rest.startsWith('[')) {
-      result[key] = rest.slice(1, rest.lastIndexOf(']')).split(',').map(s => s.trim()).filter(Boolean)
-      i++
-    } else {
-      result[key] = parseScalar(rest)
-      i++
-    }
-  }
-
-  return result
-}
-
-/** @param {string} s */
-function parseScalar(s) {
-  if (s === 'true') return true
-  if (s === 'false') return false
-  if (s === 'null' || s === '~') return null
-  const n = Number(s)
-  if (!Number.isNaN(n) && s !== '') return n
-  return s.replace(/^["']|["']$/gu, '')
-}

package/scripts/graph/lib/nnn.mjs

@@ -1,77 +0,0 @@
-/**
- * NNN-лічильники — рахують існуючі файли певного патерну і повертають наступний NNN.
- * Zero-padded до 3 цифр: 001, 002, …
- */
-import { readdirSync } from 'node:fs'
-
-/**
- * @param {string} dir абсолютний шлях до директорії вузла
- * @param {RegExp} pattern регексп для імен файлів (напр. /^run_(\d{3})\.md$/)
- * @returns {number} кількість файлів що підходять
- */
-export function countFiles(dir, pattern) {
-  try {
-    return readdirSync(dir).filter(f => pattern.test(f)).length
-  } catch {
-    return 0
-  }
-}
-
-/**
- * @param {string} dir
- * @returns {string} наступний NNN для run_NNN.md (zero-padded)
- */
-export function nextRunNNN(dir) {
-  const count = countFiles(dir, /^run_\d{3}\.md$/u)
-  return String(count + 1).padStart(3, '0')
-}
-
-/**
- * @param {string} dir
- * @returns {string} наступний NNN для plan_NNN.md (zero-padded)
- */
-export function nextPlanNNN(dir) {
-  const count = countFiles(dir, /^plan_\d{3}\.md$/u)
-  return String(count + 1).padStart(3, '0')
-}
-
-/**
- * Знаходить NNN останнього fact_NNN.md.
- * @param {string} dir
- * @returns {string | null}
- */
-export function latestFactNNN(dir) {
-  try {
-    const files = readdirSync(dir)
-      .filter(f => /^fact_\d{3}\.md$/u.test(f))
-      .sort()
-    if (files.length === 0) return null
-    return files.at(-1).replace('fact_', '').replace('.md', '')
-  } catch {
-    return null
-  }
-}
-
-/**
- * Знаходить NNN pending-audit без відповідного audit-result.
- * @param {string} dir
- * @returns {string | null}
- */
-export function pendingAuditNNN(dir) {
-  try {
-    const files = readdirSync(dir)
-    const pending = files.filter(f => /^pending-audit_\d{3}\.md$/u.test(f)).sort()
-    for (const p of pending) {
-      const nnn = p.replace('pending-audit_', '').replace('.md', '')
-      if (!files.includes(`audit-result_${nnn}.md`)) return nnn
-    }
-    return null
-  } catch {
-    return null
-  }
-}
-
-/** @param {number} n @returns {string} */
-export function pad3(n) {
-  return String(n).padStart(3, '0')
-}

package/scripts/graph/lib/state.mjs

@@ -1,110 +0,0 @@
-/**
- * Визначення стану вузла за наявністю файлів (O(1), без читання вмісту).
- * Пріоритет: invalidated > resolved > pending-audit > stalled > running > waiting/blocked > failed > needs-plan
- */
-import { existsSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-
-/**
- * @typedef {'needs-plan'|'waiting'|'blocked'|'running'|'stalled'|'pending-audit'|'resolved'|'failed'|'invalidated'} NodeState
- */
-
-/**
- * Визначає стан атомарного вузла за файлами у директорії.
- * @param {string} dir абсолютний шлях до директорії вузла
- * @param {{ depsResolved: boolean }} opts
- * @returns {NodeState}
- */
-export function deriveAtomicState(dir, { depsResolved = true } = {}) {
-  if (existsSync(join(dir, 'invalidated'))) return 'invalidated'
-
-  const files = listFiles(dir)
-
-  if (hasFact(files) && !files.includes('invalidated')) return 'resolved'
-
-  const pendingNNN = findPendingAudit(files)
-  if (pendingNNN !== null) return 'pending-audit'
-
-  const runningUntil = findRunningUntil(files)
-  if (runningUntil !== null) {
-    const ts = Number(runningUntil)
-    const now = Math.floor(Date.now() / 1000)
-    return ts > now ? 'running' : 'stalled'
-  }
-
-  const hasPlan = files.some(f => /^plan_\d{3}\.md$/u.test(f))
-  const hasRun = files.some(f => /^run_\d{3}\.md$/u.test(f))
-
-  if (!hasPlan) return 'needs-plan'
-  if (hasRun && !hasFact(files)) return 'failed'
-  if (hasPlan && !depsResolved) return 'blocked'
-  return 'waiting'
-}
-
-/**
- * Визначає стан composite вузла за станами дітей.
- * @param {string} dir
- * @param {NodeState[]} childStates
- * @returns {NodeState}
- */
-export function deriveCompositeState(dir, childStates) {
-  if (existsSync(join(dir, 'invalidated'))) return 'invalidated'
-
-  if (childStates.length === 0) return 'needs-plan'
-  if (childStates.every(s => s === 'resolved')) return 'resolved'
-  if (childStates.some(s => s === 'running' || s === 'pending-audit')) return 'running'
-  if (childStates.some(s => s === 'stalled')) return 'stalled'
-  if (childStates.some(s => s === 'failed') && !childStates.some(s => s === 'running')) return 'failed'
-  return 'waiting'
-}
-
-/**
- * Перевіряє наявність orphan worktree для вузла (resolved + worktree exists).
- * @param {string} dir
- * @param {string} worktreesDir
- * @returns {boolean}
- */
-export function hasOrphanWorktree(dir, worktreesDir) {
-  const nodeName = dir.split('/').at(-1)
-  try {
-    return readdirSync(worktreesDir).some(d => d.startsWith(nodeName))
-  } catch {
-    return false
-  }
-}
-
-// --- helpers ---
-
-/** @param {string} dir @returns {string[]} */
-function listFiles(dir) {
-  try { return readdirSync(dir) } catch { return [] }
-}
-
-/** @param {string[]} files @returns {boolean} */
-function hasFact(files) {
-  return files.some(f => /^fact_\d{3}\.md$/u.test(f))
-}
-
-/**
- * Знаходить перший pending-audit_NNN без audit-result_NNN.
- * @param {string[]} files
- * @returns {string | null} NNN або null
- */
-function findPendingAudit(files) {
-  const pending = files.filter(f => /^pending-audit_\d{3}\.md$/u.test(f)).sort()
-  for (const p of pending) {
-    const nnn = p.replace('pending-audit_', '').replace('.md', '')
-    if (!files.includes(`audit-result_${nnn}.md`)) return nnn
-  }
-  return null
-}
-
-/**
- * Знаходить `running_until_<ts>` файл і повертає ts як рядок.
- * @param {string[]} files
- * @returns {string | null}
- */
-function findRunningUntil(files) {
-  const f = files.find(f => /^running_until_\d+$/u.test(f))
-  return f ? f.replace('running_until_', '') : null
-}

package/scripts/graph/scan.mjs

@@ -1,64 +0,0 @@
-/**
- * `graph scan` — повне сканування граф: відновлює стан з файлів, виводить результат.
- * exit 0 — граф чистий; exit 1 — є вузли у стані failed.
- */
-import { resolve } from 'node:path'
-import { cwd } from 'node:process'
-
-import { loadConfig } from './lib/config.mjs'
-import { buildDag } from './lib/dag.mjs'
-
-/**
- * @param {string[]} args
- * @param {{ json?: boolean }} opts
- */
-export async function runScan(args, opts = {}) {
-  const root = cwd()
-  const config = loadConfig(root)
-  const tasksDir = resolve(root, config.tasks_dir)
-  const worktreesDir = resolve(root, config.worktrees_dir)
-
-  const nodes = buildDag(tasksDir, worktreesDir)
-
-  if (opts.json) {
-    const out = {}
-    for (const [id, node] of nodes) out[id] = { state: node.state, deps: node.deps }
-    process.stdout.write(JSON.stringify(out, null, 2) + '\n')
-  } else {
-    printScanTable(nodes)
-  }
-
-  const hasFailed = [...nodes.values()].some(n => n.state === 'failed')
-  return hasFailed ? 1 : 0
-}
-
-/** @param {Map<string, import('./lib/dag.mjs').GraphNode>} nodes */
-function printScanTable(nodes) {
-  const STATE_ICON = {
-    'needs-plan': '⏳',
-    waiting: '○',
-    blocked: '○',
-    running: '◉',
-    stalled: '⚠',
-    'pending-audit': '🔍',
-    resolved: '✓',
-    failed: '✗',
-    invalidated: '⊘',
-  }
-
-  const counts = {}
-  for (const { state } of nodes.values()) counts[state] = (counts[state] ?? 0) + 1
-
-  const summary = Object.entries(counts).map(([s, n]) => `${s}:${n}`).join(' ')
-  console.log(`graph — ${summary}\n`)
-
-  for (const [id, node] of nodes) {
-    const icon = STATE_ICON[node.state] ?? '?'
-    let detail = ''
-    if (node.state === 'needs-plan') detail = `run: graph plan tasks/${id}/`
-    else if (node.state === 'blocked') detail = `blocked: ${node.deps.join(', ')}`
-    else if (node.state === 'stalled') detail = 'stalled — deadline passed'
-    const suffix = detail ? ` [${detail}]` : ''
-    console.log(`  ${icon} ${id.padEnd(30)} [${node.state}]${suffix}`)
-  }
-}