xonecode 0.38.44 → 0.39.4

package/dist/lib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.js","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC;AAChG,OAAO,EACL,wBAAwB,GAGzB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,yBAAyB,EAAwC,MAAM,uCAAuC,CAAC;AACxH,OAAO,EAAE,iBAAiB,EAA2B,MAAM,iCAAiC,CAAC;AAC7F,OAAO,EAAE,KAAK,EAAmE,MAAM,+BAA+B,CAAC;AACvH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC3F,OAAO,EACL,qBAAqB,GAGtB,MAAM,wBAAwB,CAAC;AAChC;;;GAGG;AACH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAA0B,MAAM,mBAAmB,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/vendor/hitl.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Aprobación humana de N escrituras concurrentes.
+ *
+ * La forma de este módulo sale de la verificación en vivo, no de la intuición:
+ *
+ * 1. Los interrupts de un subagente SÍ propagan al stream de arriba.
+ * 2. Con el orquestador emitiendo dos `task` en un turno, quedan DOS interrupts
+ *    pendientes a la vez (`tasks.length === 2`, `next === ["tools","tools"]`).
+ * 3. El resume tiene que ser un MAPA por id de interrupt. Un array pelado falla con
+ *    "Invalid HITLResponse: decisions must be a non-empty array".
+ * 4. El interrupt NO dice de qué subagente viene, así que la atribución viaja en la
+ *    `description` que cada subagente pone en su `InterruptOnConfig`.
+ *
+ * De ahí que esto no pueda ser un "pregunta una cosa y reanuda": hay que recoger
+ * todos los pendientes, preguntar por cada uno, y reanudar con un único Command.
+ */
+export interface PendingInterrupt {
+    id: string;
+    tool: string;
+    args: Record<string, unknown>;
+    description: string;
+    allowedDecisions: string[];
+}
+export interface Decision {
+    type: "approve" | "reject";
+    message?: string;
+}
+/**
+ * Tope de rondas de aprobación. Sin él, un modelo que insista tras cada rechazo
+ * convierte el bucle en un ciclo automático de ~200k tokens por ronda. Lo comparten
+ * da04 y la consola.
+ */
+export declare const MAX_APPROVAL_ROUNDS = 5;
+/**
+ * El mensaje de rechazo tiene que dejar clarísimo que NO se aplicó nada: si solo dice
+ * "no la reintentes", el modelo puede sintetizar la respuesta final como si la
+ * escritura hubiese quedado lista — la salida contradiciendo lo que realmente pasó.
+ */
+export declare const REJECT_MESSAGE: string;
+export declare function collectPending(state: unknown): PendingInterrupt[];
+/**
+ * El mapa `{ id → { decisions: [...] } }` que espera `new Command({ resume })`.
+ *
+ * **Una interrupción con N acciones necesita N decisiones, en ORDEN.** Por eso esto vuelve
+ * a agrupar lo que `collectPending` desplegó: la lista se dimensiona con el total que viaja
+ * en el id, y cada decisión se coloca en su índice.
+ *
+ * **El hueco que quede se RECHAZA**, que es la dirección de siempre: una decisión que falta
+ * es una que nadie tomó, y aprobar por omisión una escritura sobre el proyecto del cliente
+ * es justo lo que la aprobación existe para impedir. Aquí no debería pasar nunca —quien
+ * llama resuelve todas las pendientes, a mano o automáticas—, pero si pasa, el turno sigue
+ * y lo que no se decidió no se aplica, en vez de reventar con un descuadre de números.
+ */
+export declare function buildResume(decisions: Map<string, Decision>): Record<string, {
+    decisions: Decision[];
+}>;
+/**
+ * Interpreta una respuesta de aprobación, sin imprimir nada ni preguntar: es la
+ * parte pura de promptForDecisions, para que la consola TUI la reutilice.
+ *
+ * Fail-closed: el Enter a secas solo aprueba con `interactive: true` explícito (un
+ * TTY de verdad detrás); cualquier otra respuesta que no se entiende es rechazo.
+ */
+export declare function interpretAnswer(answer: string, opts?: {
+    interactive?: boolean;
+}): Decision;
+export declare function promptForDecisions(pending: PendingInterrupt[], ask: (question: string) => Promise<string>, opts?: {
+    interactive?: boolean;
+}): Promise<Map<string, Decision>>;

package/dist/vendor/skillLoaders/catalog.d.ts

@@ -0,0 +1,27 @@
+export interface SkillInfo {
+    name: string;
+    description: string;
+    /** Cuerpo del SKILL.md sin el frontmatter. */
+    content: string;
+    /** Directorio del skill, para resolver rutas relativas. */
+    dir: string;
+    /** Ficheros del skill (sin el SKILL.md), relativos al directorio, ordenados. */
+    files: string[];
+}
+export interface Frontmatter {
+    name?: string;
+    description?: string;
+}
+/**
+ * Frontmatter YAML mínimo: `clave: valor` de una línea entre delimitadores `---`.
+ * No se usa un parser de YAML a propósito — los skills reales solo necesitan esto y
+ * una dependencia más sería ruido en un experimento sobre coste de contexto.
+ */
+export declare function parseFrontmatter(content: string): {
+    data: Frontmatter;
+    body: string;
+};
+/** Ficheros del skill salvo el propio SKILL.md, en rutas relativas con `/`, ordenadas. */
+export declare function listSkillFiles(dir: string, limit?: number): string[];
+/** Lee un directorio de skill: frontmatter, cuerpo y ficheros. */
+export declare function loadSkill(dir: string, fileLimit?: number): SkillInfo;

package/dist/vendor/sqliteSaver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adaptado de @langchain/langgraph-checkpoint-sqlite@1.0.4 (MIT, © 2024 LangChain).
+ * Véase THIRD_PARTY_NOTICES.md. Se incluye para usar better-sqlite3 13 en npm.
+ */
+import { Database as DatabaseType, Statement } from "better-sqlite3";
+import type { RunnableConfig } from "@langchain/core/runnables";
+import { BaseCheckpointSaver, type Checkpoint, type CheckpointListOptions, type CheckpointTuple, type SerializerProtocol, type PendingWrite, type CheckpointMetadata } from "@langchain/langgraph-checkpoint";
+export declare class SqliteSaver extends BaseCheckpointSaver {
+    db: DatabaseType;
+    protected isSetup: boolean;
+    protected withoutCheckpoint: Statement;
+    protected withCheckpoint: Statement;
+    constructor(db: DatabaseType, serde?: SerializerProtocol);
+    static fromConnString(connStringOrLocalPath: string): SqliteSaver;
+    protected setup(): void;
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    list(config: RunnableConfig, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
+    putWrites(config: RunnableConfig, writes: PendingWrite[], taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+    protected migratePendingSends(checkpoint: Checkpoint, threadId: string, parentCheckpointId: string): Promise<void>;
+}

package/dist/vendor/tokenTracking.d.ts

@@ -0,0 +1,22 @@
+export interface TokenTracker {
+    input: number;
+    output: number;
+    cache: number;
+    calls: number;
+    /** El input de la ÚLTIMA llamada: cuánto ocupa AHORA la ventana del modelo.
+     *
+     * Los acumulados dicen lo que la sesión HA costado; esto dice cuánto queda
+     * de margen antes de que el historial desborde el contexto — dos preguntas
+     * distintas y la segunda es la que la barra de estado necesita. */
+    contexto: number;
+}
+export type AlContarTokens = (uso: {
+    input: number;
+    output: number;
+    cache: number;
+    llamadas: number;
+    contexto: number;
+}) => void;
+export declare function createTokenTracker(): TokenTracker;
+export declare function createTokenTrackingMiddleware(tracker: TokenTracker, alContar?: AlContarTokens): import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[], readonly []>;
+export declare function printTokenUsage(tracker: TokenTracker, latencyMs?: number): void;