@arcforge/cognet 2.0.115 → 2.0.116

package/src/air/render/index.ts

@@ -1,51 +0,0 @@
-import type { GrammarT } from "../grammar"
-import type { AirMessage, AirRenderInput } from "../types"
-import {
-    renderContract,
-    renderMeta,
-    renderScope,
-    renderSystem,
-    renderTimeline,
-} from "./blocks"
-
-type RenderOpts = {
-    grammar: GrammarT
-}
-
-/**
- * Render — domain in, ordered messages out. Pure.
- *
- * The caller passes what it holds (base string, AxonTool[], AxonEntry[]);
- * the block renderers own every translation into protocol shape. System
- * sections (meta, scope, system, contract) become individual system messages;
- * the timeline becomes a single user message — proper conversation structure
- * rather than one monolithic system prompt.
- *
- * Section order: <meta> → <scope> → <system> → <contract> → timeline
- */
-export function Render(opts: RenderOpts) {
-    const { grammar } = opts
-
-    return {
-        render(input: AirRenderInput): AirMessage[] {
-            const messages: AirMessage[] = []
-
-            const sys = (content: string) => {
-                if (content) messages.push({ role: "system", content })
-            }
-
-            sys(renderMeta(grammar))
-            if (input.scope) sys(renderScope(input.scope))
-            sys(renderSystem(input.base))
-            sys(renderContract(grammar))
-
-            if (input.history && input.history.length > 0) {
-                messages.push({ role: "user", content: renderTimeline(input.history, grammar) })
-            }
-
-            return messages
-        },
-    }
-}
-
-export type RenderT = ReturnType<typeof Render>

package/src/air/render/output.ts

@@ -1,144 +0,0 @@
-import { formatBytes } from "./text"
-
-/**
- * Capsule output projection — how raw capsule REPL output looks to the model.
- *
- * The capsule REPL emits a JSONL op-record envelope for every module function
- * call, followed by the raw auto-logged return value. This detects that
- * envelope, extracts the meaningful content per op type, and discards the
- * noise.
- *
- * For content-returning ops (fs.read, fs.list, ...) — show the content.
- * For mutation ops (fs.write, fs.mkdir, ...) — show a compact tick line.
- * For anything else — pass through unchanged.
- *
- * The silent catch fall-throughs here are correct, not masked failures:
- * this is a best-effort display projection where "show the raw string"
- * is the honest fallback for anything that doesn't parse.
- */
-export function formatCapsuleOutput(content: string): string {
-    const raw = content.trim()
-
-    // Plain JSON array — e.g. fs.list() return value serialised directly
-    if (raw.startsWith("[")) {
-        try {
-            const arr = JSON.parse(raw)
-            if (Array.isArray(arr)) {
-                if (arr.length === 0) return "(empty)"
-                // DirEntry[] — render as a compact directory listing
-                if (
-                    arr.length > 0 &&
-                    typeof arr[0] === "object" &&
-                    arr[0] !== null &&
-                    "name" in arr[0]
-                ) {
-                    return arr
-                        .map((e: any) => `${e.type === "directory" ? "d" : "-"}  ${e.name}`)
-                        .join("\n")
-                }
-                // Generic array of primitives or unknown objects
-                return arr
-                    .map((e: any) => (typeof e === "object" ? JSON.stringify(e) : String(e)))
-                    .join("\n")
-            }
-        } catch {
-            /* not JSON — fall through to raw */
-        }
-        return raw
-    }
-
-    if (!raw.startsWith("{")) return raw
-
-    // Extract all leading JSON op-record objects.
-    // Everything after the last op record (the raw auto-logged return value)
-    // is discarded — the meaningful content comes from the op record's data field.
-    const opRecords: any[] = []
-    let i = 0
-    while (i < raw.length && raw[i] === "{") {
-        let depth = 0
-        let j = i
-        while (j < raw.length) {
-            const ch = raw[j]
-            if (ch === '"') {
-                // skip over string contents, respecting escape sequences
-                j++
-                while (j < raw.length) {
-                    if (raw[j] === "\\") {
-                        j += 2
-                        continue
-                    }
-                    if (raw[j] === '"') {
-                        j++
-                        break
-                    }
-                    j++
-                }
-                continue
-            }
-            if (ch === "{") depth++
-            else if (ch === "}") {
-                depth--
-                if (depth === 0) {
-                    j++
-                    break
-                }
-            }
-            j++
-        }
-        try {
-            const obj = JSON.parse(raw.slice(i, j))
-            if ("op" in obj) opRecords.push(obj)
-            else if ("procId" in obj && "command" in obj) {
-                const tail = obj.tail ? `\n${obj.tail}` : ""
-                return `spawned  ${obj.command}  procId=${obj.procId}  pid=${obj.pid ?? "?"}  status=${obj.status ?? "running"}${tail}`
-            } else break
-        } catch {
-            break
-        }
-        i = j
-        while (i < raw.length && (raw[i] === "\n" || raw[i] === "\r")) i++
-    }
-
-    if (opRecords.length === 0) return raw
-
-    return opRecords
-        .map(obj => {
-            const op: string = obj.op ?? ""
-            const d = obj.data ?? {}
-
-            if (!obj.ok) {
-                return `${op}  ${d.path ?? ""}  ✗ ${obj.error ?? d.message ?? "failed"}`
-            }
-
-            switch (op) {
-                case "fs.read":
-                case "fs.readLines":
-                    return `read  ${d.path}  ${formatBytes(d.bytes ?? 0)}\n${d.content ?? ""}`
-                case "fs.list": {
-                    const entries: any[] = d.entries ?? []
-                    const lines = entries
-                        .map((e: any) => {
-                            const prefix = e.type === "directory" ? "d" : "-"
-                            return `${prefix}  ${e.name}`
-                        })
-                        .join("\n")
-                    return `list  ${d.path}  ${entries.length} entries\n${lines}`
-                }
-                case "fs.write":
-                    return `write  ${d.path}  ${formatBytes(d.bytes ?? 0)}  ✓`
-                case "fs.mkdir":
-                    return `mkdir  ${d.path}  ✓`
-                case "fs.delete":
-                    return `rm     ${d.path}  ✓`
-                case "fs.move":
-                    return `mv     ${d.src} → ${d.dest}  ✓`
-                case "fs.copy":
-                    return `cp     ${d.src} → ${d.dest}  ✓`
-                case "fs.cd":
-                    return `cd     ${d.path}  ✓`
-                default:
-                    return `${op}  ${JSON.stringify(d)}  ✓`
-            }
-        })
-        .join("\n")
-}

package/src/air/render/text.ts

@@ -1,85 +0,0 @@
-/** Pure string utilities for AIR rendering. */
-
-/** Escape XML text content (prose, stdout, user messages). */
-export function esc(s: string): string {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
-}
-
-/** Escape a trusted value for a double-quoted XML attribute. */
-export function escAttr(s: string): string {
-    return esc(s).replace(/"/g, "&quot;").replace(/'/g, "&apos;")
-}
-
-/** Escape XML inside code blocks — only & and <. Never > (breaks =>, generics). */
-export function escCode(s: string): string {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;")
-}
-
-/** Indent every line of s by `spaces` spaces. */
-export function indent(s: string, spaces: number): string {
-    const pad = " ".repeat(spaces)
-    return s
-        .split("\n")
-        .map(line => pad + line)
-        .join("\n")
-}
-
-export function formatBytes(n: number): string {
-    return n >= 1024 ? `${(n / 1024).toFixed(1)}K` : `${n}B`
-}
-
-/**
- * Normalize code that may contain literal \n or \t escape sequences outside
- * of string literals (a common model mistake). Replaces them with real
- * whitespace so the timeline shows clean, executable code.
- *
- * Best-effort heuristic: only acts on \n/\t outside single-quoted,
- * double-quoted, or template-literal strings.
- */
-export function normalizeCode(code: string): string {
-    // Fast path: no escape sequences at all
-    if (!code.includes("\\n") && !code.includes("\\t")) return code
-
-    let result = ""
-    let i = 0
-    while (i < code.length) {
-        const c = code[i]
-        // Track string boundaries to avoid replacing inside strings
-        if (c === '"' || c === "'" || c === "`") {
-            const quote = c
-            result += c
-            i++
-            while (i < code.length) {
-                const sc = code[i]
-                if (sc === "\\") {
-                    // Keep escape sequences inside strings as-is
-                    result += code[i] + (code[i + 1] ?? "")
-                    i += 2
-                } else if (sc === quote) {
-                    result += sc
-                    i++
-                    break
-                } else {
-                    result += sc
-                    i++
-                }
-            }
-        } else if (c === "\\" && i + 1 < code.length) {
-            const next = code[i + 1]
-            if (next === "n") {
-                result += "\n"
-                i += 2
-            } else if (next === "t") {
-                result += "\t"
-                i += 2
-            } else {
-                result += c + next
-                i += 2
-            }
-        } else {
-            result += c
-            i++
-        }
-    }
-    return result
-}

package/src/air/repair/index.ts

@@ -1 +0,0 @@
-export { repair } from "./repair"

package/src/air/repair/repair.ts

@@ -1,33 +0,0 @@
-/**
- * Deterministic, pre-parse repair of raw model output.
- *
- * Scope is deliberately narrow: string-only fixes for mistakes that are
- * common and unambiguous to correct. No semantic guessing, no model calls.
- * If a fix isn't mechanically certain, leave the text alone — the parser's
- * own incomplete/error reporting is the honest fallback, and that goes back
- * to the model as an `agent:output:error` for it to correct itself.
- *
- * Applied to the full buffered response before it reaches the AIR parser.
- */
-
-const KNOWN_TAGS = ["text", "thinking", "typescript", "script", "template"] as const
-
-export function repair(raw: string): string {
-    return normalizeTagCase(raw)
-}
-
-/**
- * Lowercase tag names the model emitted in the wrong case
- * (`<Text>`, `<TYPESCRIPT>`) — case is not semantically meaningful here,
- * so normalizing it can never change intent, only make it parseable.
- */
-function normalizeTagCase(raw: string): string {
-    let out = raw
-    for (const tag of KNOWN_TAGS) {
-        const open = new RegExp(`<(${tag})(\\s[^>]*)?>`, "gi")
-        const close = new RegExp(`</(${tag})>`, "gi")
-        out = out.replace(open, (match, _name, attrs) => `<${tag}${attrs ?? ""}>`)
-        out = out.replace(close, `</${tag}>`)
-    }
-    return out
-}

package/src/air/types.ts

@@ -1,88 +0,0 @@
-/**
- * AIR — Agent Intermediate Representation.
- *
- * A general-purpose LLM protocol: hand the renderer Axon's domain (base
- * context, declared tools, an event history) and it produces the ordered
- * messages a model sees. AIR owns BOTH halves — render (what the model
- * sees) and parse (what it emits back) — from one grammar, so they cannot
- * drift.
- *
- * The render boundary is DOMAIN in, messages out: callers pass AxonTool[]
- * and AxonEntry[], never AIR's internal render vocabulary. The
- * timeline item shapes below are private to render/ — the exhaustive
- * AxonEntry → item translation lives there, next to the parser it
- * must agree with.
- */
-
-import type { AxonEntry, AxonScope } from "@arcforge/types"
-
-// ── Messages ─────────────────────────────────────────────────────────────────
-
-export type AirMessage = {
-    role: "system" | "user" | "assistant"
-    content: string
-}
-
-// ── Protocols (output grammar) ───────────────────────────────────────────────
-
-/**
- * The named output grammars.
- *
- * classic — <typescript> acts, <text> speaks. Two independent blocks.
- * sfc     — <script> computes, <template> speaks. One response, script first.
- * raw     — no grammar; the whole reply is the message. For internal calls.
- */
-export type AirProtocolName = "classic" | "sfc" | "raw"
-
-export type AirModeType = "text" | "typescript" | "script" | "template"
-
-export type AirMode = {
-    /** The output type this mode produces. */
-    type: AirModeType
-    /** Optional description override. Falls back to the default for the type. */
-    description?: string
-}
-
-/** Template languages. Selects the interpolation serializer. */
-export type AirTemplateLang = "md" | "json"
-
-// ── Render input ───────────────────────────────────────────────────────────
-//
-// DOMAIN in — the caller passes what it already holds. AIR owns every
-// translation into protocol shape: tools → <scope> declarations, entries →
-// <timeline> items. A cognet curates (which entries, what order, elided how)
-// and hands the lists over; it never manufactures AIR-internal types.
-
-export type AirRenderInput = {
-    /** Base context — the agent's identity contract. Rendered as <system>. */
-    base?: string
-    /** Capsule-implemented globals. Rendered as <scope lang="ts">. */
-    scope?: AxonScope
-    /** The event history to render, already curated by the cognet. Rendered as <timeline>. */
-    history?: readonly AxonEntry[]
-}
-
-// ── Parser output ────────────────────────────────────────────────────────────
-
-/**
- * Events emitted by the streaming AIR parser.
- *
- * *:delta — tokens inside a streamable block (<text>, <thinking>), real time.
- * *:done  — a block closed; content is the full inner text.
- *           `incomplete: true` means the stream ended without the closing tag —
- *           callers must treat these as format errors, never as valid actions.
- * done    — a <done/> self-closing tag was encountered.
- */
-export type AirBlockEvent =
-    | { type: "text:delta"; content: string }
-    | { type: "text:done"; content: string; incomplete?: true }
-    | { type: "thinking:delta"; content: string }
-    | { type: "thinking:done"; content: string; incomplete?: true }
-    | { type: "typescript:done"; content: string; incomplete?: true }
-    // SFC. script:done is the suspension point — the consumer runs it and
-    // resolves a scope before template deltas may be released.
-    | { type: "script:done"; content: string; incomplete?: true }
-    | { type: "template:open"; lang: AirTemplateLang }
-    | { type: "template:delta"; content: string }
-    | { type: "template:done"; content: string; incomplete?: true }
-    | { type: "done" }