nexakit 0.1.0 → 0.2.0

package/src/model-command.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { getStaticTOMLValue, parseTOML } from 'toml-eslint-parser';
+import { agentModels } from './agent-models.js';
+import { resolveCliInvocation } from './cli-executable.js';
+import { runRevisionProcess } from './revision-process.js';
+import pkg from '../package.json' with { type: 'json' };
+
+export async function inspectModels({
+  homeDirectory = os.homedir(),
+  environment = process.env,
+  codexProfile,
+  runCommand,
+  includeAntigravity = true,
+} = {}) {
+  const codexHome = environment.CODEX_HOME ?? path.join(homeDirectory, '.codex');
+  const claudeHome = environment.CLAUDE_CONFIG_DIR ?? path.join(homeDirectory, '.claude');
+  const old = await agentModels({ codexHome, claudeHome });
+  let cache = {},
+    config = {},
+    settings = {};
+  try {
+    cache = JSON.parse(await fs.readFile(path.join(codexHome, 'models_cache.json'), 'utf8'));
+  } catch {}
+  try {
+    config = getStaticTOMLValue(parseTOML(await fs.readFile(path.join(codexHome, 'config.toml'), 'utf8')));
+  } catch {}
+  try {
+    settings = JSON.parse(await fs.readFile(path.join(claudeHome, 'settings.json'), 'utf8'));
+  } catch {}
+  const profile = codexProfile ?? config.profile;
+  const selected = profile ? config.profiles?.[profile] : null;
+  let storedCodex =
+    profile && !selected
+      ? null
+      : {
+          model: selected?.model ?? config.model ?? null,
+          effort: selected?.model_reasoning_effort ?? config.model_reasoning_effort ?? null,
+        };
+  // Modern Codex profiles can also be separate files; no shell interpolation.
+  if (profile && /^[a-zA-Z0-9._-]+$/u.test(profile)) {
+    try {
+      const layer = getStaticTOMLValue(
+        parseTOML(await fs.readFile(path.join(codexHome, `${profile}.config.toml`), 'utf8')),
+      );
+      storedCodex = {
+        model: layer.model ?? config.model ?? null,
+        effort: layer.model_reasoning_effort ?? config.model_reasoning_effort ?? null,
+      };
+    } catch {}
+  }
+  let antigravity = [],
+    error = null;
+  if (includeAntigravity) {
+    try {
+      let result;
+      if (runCommand) result = await runCommand('agy', ['models']);
+      else {
+        const cli = await resolveCliInvocation({ name: 'agy', environment });
+        result = await runRevisionProcess(
+          { executable: cli.executable, args: [...cli.argsPrefix, 'models'], env: environment },
+          { prompt: '', timeoutMs: 20000 },
+        );
+      }
+      if (result.status !== 0 || result.timedOut) throw new Error('No se pudo consultar agy models.');
+      antigravity = result.stdout.split('\n').flatMap((line) => {
+        const [model, label] = line.split('\t');
+        const effort = model?.match(/-(low|medium|high|xhigh|max)$/u)?.[1];
+        return model && label && effort
+          ? [{ model, description: label, efforts: [effort], defaultEffort: effort }]
+          : [];
+      });
+    } catch (e) {
+      error = e.message;
+    }
+  }
+  const codex = old.codex.models.map((item) => ({
+    ...item,
+    defaultEffort: cache.models?.find((m) => m.slug === item.model)?.default_reasoning_level ?? null,
+  }));
+  return {
+    catalogs: { claude: old.claude.map((m) => ({ ...m, defaultEffort: 'medium' })), codex, antigravity },
+    stored: {
+      claude: {
+        model: settings.model ?? null,
+        effort: settings.modelSettings?.[settings.model]?.effortLevel ?? settings.effortLevel ?? null,
+      },
+      codex: storedCodex,
+      antigravity: null,
+    },
+    sources: {
+      claude: `lista incluida en nexakit ${pkg.version}`,
+      codex: 'models_cache.json de Codex',
+      antigravity: error ?? 'agy models; el esfuerzo forma parte del id',
+    },
+    levels: old.levels,
+  };
+}
+
+export async function validateReviewChoice(options) {
+  const data = await inspectModels({ ...options, includeAntigravity: options.client === 'antigravity' });
+  const match = data.catalogs[options.client]?.find((item) => item.model === options.model);
+  if (!match || !match.efforts.includes(options.effort))
+    throw new Error('Modelo o esfuerzo no disponible en el catálogo real; consulta nexakit modelo.');
+}
+export async function runModelCommand(args, { out, err }, options = {}) {
+  let level, client, profile;
+  const seen = new Set();
+  for (let i = 0; i < args.length; i++) {
+    const flag = args[i],
+      value = args[++i];
+    if (seen.has(flag) || !value) {
+      await err('Argumentos de modelo inválidos.\n');
+      return 2;
+    }
+    seen.add(flag);
+    if (flag === '--nivel') level = value;
+    else if (flag === '--ia') client = value;
+    else if (flag === '--perfil-codex') profile = value;
+    else return 2;
+  }
+  if (client && !['claude', 'codex', 'antigravity'].includes(client)) return 2;
+  const data = await inspectModels({ ...options, codexProfile: profile });
+  const row = level ? data.levels.find((x) => x.level.toLowerCase() === level.toLowerCase()) : null;
+  if (level && !row) return 2;
+  for (const ia of client ? [client] : ['claude', 'codex', 'antigravity']) {
+    await out(`${ia}: ${data.sources[ia]}\n`);
+    for (const model of data.catalogs[ia])
+      await out(
+        `  ${model.model} · ${model.efforts.join(', ')} · defecto ${model.defaultEffort ?? 'no informado'}\n`,
+      );
+    const stored = data.stored[ia],
+      wanted = row?.[ia];
+    const mark =
+      !stored?.model || !stored?.effort || !wanted
+        ? '?'
+        : stored.model === wanted.model && stored.effort === wanted.effort
+          ? '✓'
+          : '→';
+    await out(
+      `${mark} Guardado: ${stored?.model ?? 'no comprobable'} · ${stored?.effort ?? 'no informado'}${wanted ? ` · recomendado ${wanted.model} · ${wanted.effort}` : ''}\n`,
+    );
+  }
+  await out('Compara lo guardado; una sesión abierta puede diferir. Compruébalo en /model.\n');
+  return 0;
+}

package/src/panel-cli.js

@@ -0,0 +1,182 @@
+// `nexakit panel`: dibuja a pantalla completa la orquesta de la sesión de Claude Code (líder, asesor, subagentes,
+// uso). El mod nexakit-panel guarda una foto del estado real en ~/.nexakit/panel/actual.json en cada cambio; este
+// comando la lee cada segundo y la pinta con el mismo lienzo que usa el panel dentro de Claude.
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { ANCHO, aAnsi, dibujar } from '../plugins/nexakit-panel/hooks/lienzo.js';
+import { ejemplo, hora } from '../plugins/nexakit-panel/hooks/panel.js';
+import { colorLevel } from './brand.js';
+import { cellWidth, fitLine } from './terminal-text.js';
+
+export const INACTIVA_MS = 10 * 60 * 1000;
+const USO_EJEMPLO = { context: { window: 1000000, percent: 55 }, rateLimits: [{ kind: 'five_hour', percentUsed: 14 }, { kind: 'seven_day', percentUsed: 79 }] };
+const AYUDA = `Uso: nexakit panel [--demo] [--una-vez]
+
+Dibuja la orquesta de tu sesión de Claude Code a pantalla completa: ábrelo en una división de la terminal al
+lado de Claude. Se actualiza solo cada segundo; q o Ctrl+C para salir. Necesita el mod nexakit-panel en
+Claude Code y una ventana de al menos ${ANCHO} columnas.
+  --demo      datos de ejemplo, marcados como ficticios, para ver el diseño
+  --una-vez   dibuja una vez y sale
+`;
+
+export async function leerFoto(homeDirectory) {
+  try {
+    const foto = JSON.parse(await fs.readFile(path.join(homeDirectory, '.nexakit', 'panel', 'actual.json'), 'utf8'));
+    return foto?.version === 1 && foto.estado && typeof foto.estado === 'object' ? foto : null;
+  } catch {
+    return null;
+  }
+}
+
+// La sesión más reciente de Codex (~/.codex/sessions/AAAA/MM/DD/*.jsonl): modelo, tokens y límites. Es un formato
+// interno de Codex: si cambia o falta algo, se devuelve null en vez de inventar cifras.
+export async function leerCodex(codexHome) {
+  try {
+    const base = path.join(codexHome, 'sessions');
+    const desc = async (dir) => (await fs.readdir(dir, { withFileTypes: true }).catch(() => []))
+      .filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+    const archivos = [];
+    for (const anio of (await desc(base)).slice(0, 2))
+      for (const mes of (await desc(path.join(base, anio))).slice(0, 2))
+        for (const dia of (await desc(path.join(base, anio, mes))).slice(0, 3))
+          for (const nombre of await fs.readdir(path.join(base, anio, mes, dia)).catch(() => []))
+            if (nombre.endsWith('.jsonl')) archivos.push(path.join(base, anio, mes, dia, nombre));
+    if (archivos.length === 0) return null;
+    const conFecha = await Promise.all(archivos.map(async (f) => ({ f, t: (await fs.stat(f)).mtimeMs })));
+    const { f, t } = conFecha.sort((a, b) => b.t - a.t)[0];
+    const datos = await fs.readFile(f);
+    const lineas = datos.subarray(Math.max(0, datos.length - 1_048_576)).toString('utf8').split('\n');
+    let cuenta = null, turno = null;
+    for (let i = lineas.length - 1; i >= 0 && !(cuenta && turno); i--) {
+      let d;
+      try { d = JSON.parse(lineas[i]); } catch { continue; }
+      if (!cuenta && d?.payload?.type === 'token_count' && d.payload.info?.total_token_usage) cuenta = d.payload;
+      if (!turno && d?.type === 'turn_context' && d.payload?.model) turno = d.payload;
+    }
+    if (!cuenta) return null;
+    const total = cuenta.info.total_token_usage;
+    const numero = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+    return {
+      modelo: turno?.model ?? null,
+      esfuerzo: turno?.effort ?? null,
+      leidos: numero(total.input_tokens) ?? 0,
+      cache: numero(total.cached_input_tokens) ?? 0,
+      escritos: numero(total.output_tokens) ?? 0,
+      limite5h: numero(cuenta.rate_limits?.primary?.used_percent),
+      limiteSemana: numero(cuenta.rate_limits?.secondary?.used_percent),
+      actualizado: t,
+    };
+  } catch {
+    return null;
+  }
+}
+
+const centrada = (texto, columnas) => {
+  const t = fitLine(texto, columnas);
+  return ' '.repeat(Math.max(0, Math.floor((columnas - cellWidth(t)) / 2))) + t;
+};
+const tenue = (texto, nivel) => (nivel === 'none' ? texto : `\x1b[2m${texto}\x1b[22m`);
+
+export function marcoDelPanel({ foto, columnas = ANCHO, filas, nivel = 'none', ahora = Date.now(), demo = false, codex = null }) {
+  if (columnas < ANCHO) {
+    return ['', centrada('NEXAKIT · ORQUESTA', columnas), '',
+      centrada(`El panel necesita ${ANCHO} columnas (ahora ${columnas}).`, columnas),
+      tenue(centrada('Ensancha esta división de la terminal.', columnas), nivel)].join('\n');
+  }
+  const estado = demo ? ejemplo(ahora) : foto?.estado;
+  if (!estado && codex) {
+    const { filas: lineas } = dibujar({ ...ejemplo(ahora), pasos: 0, agentes: [], registro: [] }, { ahora, uso: null, codex });
+    const margen = ' '.repeat(Math.floor((columnas - ANCHO) / 2));
+    return [...aAnsi(lineas, nivel).split('\n').map((l) => margen + l), tenue(centrada('Sin actividad de Claude Code todavía.', columnas), nivel)].join('\n');
+  }
+  if (!estado) {
+    return ['', centrada('NEXAKIT · ORQUESTA', columnas), '',
+      centrada('Esperando actividad de Claude Code…', columnas),
+      tenue(centrada('Abre Claude Code con el mod nexakit-panel y trabaja con normalidad: este panel se llena solo.', columnas), nivel)].join('\n');
+  }
+  const quieta = !demo && Number.isFinite(foto?.actualizado) && ahora - foto.actualizado > INACTIVA_MS;
+  const { filas: lineas } = dibujar(estado, {
+    ahora,
+    uso: demo ? USO_EJEMPLO : foto.uso,
+    carpeta: demo ? 'app' : foto.carpeta,
+    filasMax: filas ? filas - 1 - (quieta ? 1 : 0) : undefined,
+    asesorModelo: demo ? null : foto.asesorModelo,
+    esEjemplo: demo,
+    codex,
+  });
+  const margen = ' '.repeat(Math.floor((columnas - ANCHO) / 2));
+  const cuerpo = aAnsi(lineas, nivel).split('\n').map((linea) => margen + linea);
+  if (quieta) cuerpo.push(tenue(`${margen}  sin actividad desde ${hora(foto.actualizado)}`, nivel));
+  return cuerpo.join('\n');
+}
+
+export async function runPanelCommand(rest, { out, err, input = process.stdin, output = process.stdout, isTTY, options = {} }) {
+  const flags = new Set(rest);
+  if (rest.some((a) => !['--demo', '--una-vez', '--help', '-h'].includes(a)) || flags.size !== rest.length) {
+    await err(AYUDA);
+    return 2;
+  }
+  if (flags.has('--help') || flags.has('-h')) {
+    await out(AYUDA);
+    return 0;
+  }
+  const homeDirectory = options.homeDirectory ?? os.homedir();
+  const environment = options.environment ?? process.env;
+  const codexHome = options.codexHome ?? environment.CODEX_HOME ?? path.join(homeDirectory, '.codex');
+  const demo = flags.has('--demo');
+  const interactive = !flags.has('--una-vez') && Boolean(isTTY ?? (input?.isTTY && output?.isTTY));
+  const nivel = interactive ? colorLevel(output) : 'none';
+  const marco = async () => marcoDelPanel({
+    foto: demo ? null : await leerFoto(homeDirectory),
+    columnas: output?.columns || (interactive ? 80 : 120),
+    filas: interactive ? output?.rows : undefined,
+    nivel,
+    ahora: Date.now(),
+    demo,
+    codex: await leerCodex(codexHome),
+  });
+
+  if (!interactive) {
+    await out(`${await marco()}\n`);
+    return 0;
+  }
+
+  // Pantalla alterna: se redibuja en el sitio, línea a línea, sin parpadeo ni llenar el historial.
+  return new Promise((resolve) => {
+    let cerrado = false;
+    let dibujando = false;
+    const pintar = async () => {
+      if (cerrado || dibujando) return;
+      dibujando = true;
+      try {
+        const texto = await marco();
+        if (!cerrado) output.write(`\x1b[H${texto.split('\n').map((l) => `${l}\x1b[K`).join('\n')}\x1b[J`);
+      } finally {
+        dibujando = false;
+      }
+    };
+    const reloj = setInterval(pintar, 1000);
+    const cerrar = () => {
+      if (cerrado) return;
+      cerrado = true;
+      clearInterval(reloj);
+      input.off?.('data', alPulsar);
+      output.off?.('resize', pintar);
+      try { if (typeof input.setRawMode === 'function') input.setRawMode(false); } catch {}
+      try { input.pause?.(); } catch {}
+      output.write('\x1b[?25h\x1b[?1049l');
+      resolve(0);
+    };
+    const alPulsar = (datos) => {
+      const tecla = String(datos);
+      if (tecla === 'q' || tecla === 'Q' || tecla === '\x03') cerrar();
+    };
+    output.write('\x1b[?1049h\x1b[?25l');
+    try { if (typeof input.setRawMode === 'function') input.setRawMode(true); } catch {}
+    input.on?.('data', alPulsar);
+    input.resume?.();
+    output.on?.('resize', pintar);
+    pintar();
+  });
+}

package/src/project-root.js

@@ -0,0 +1,41 @@
+// Decides which folder is "the project": the whole Git repository, even when nexakit runs from a subfolder, so
+// one memory and one skill install serve the whole repository. Read-only: it only asks Git and reads paths.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+// Same rule the memory uses for its id (src/init.js).
+const PROJECT_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
+const FALLBACK_ID = 'proyecto';
+
+export const runGit = (args, cwd) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+
+export function projectIdentity(root) {
+  const name = path.basename(root);
+  const id = name.toLowerCase().replace(/[^a-z0-9]+/gu, '-').replace(/^-+|-+$/gu, '');
+  const valid = PROJECT_ID_PATTERN.test(id) && id.length >= 2 && id.length <= 64;
+  return { id: valid ? id : FALLBACK_ID, displayName: name.replace(/[_-]+/gu, ' ').replace(/\s+/gu, ' ').trim() || name };
+}
+
+const realpathOrNull = target => fs.realpath(target).catch(() => null);
+
+// Any Git failure (not installed, not a repository, dubious ownership) means "no Git": detection never breaks on it.
+async function gitTopLevel(startedIn, run) {
+  try {
+    const output = String(run(['rev-parse', '--show-toplevel'], startedIn) ?? '').trim();
+    return output ? await realpathOrNull(output) : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveProjectRoot(start, { homeDirectory = os.homedir(), runGit: run = runGit } = {}) {
+  const startedIn = await fs.realpath(start);
+  const topLevel = await gitTopLevel(startedIn, run);
+  // A repository at the home folder (dotfiles) is not the project: climbing there would scan and install into ~.
+  const home = await realpathOrNull(homeDirectory);
+  const git = Boolean(topLevel) && topLevel !== home;
+  const root = git ? topLevel : startedIn;
+  return { root, startedIn, git, fromSubfolder: root !== startedIn, ...projectIdentity(root) };
+}