kenaz 0.3.3 → 0.3.6

package/core/.formation/tools/worktree-leak.test.js

@@ -1,162 +0,0 @@
-/**
- * TASK_1530 — regression test for the Bifrost/Codex worktree WRITE-LEAK class.
- *
- * Confirmed external-user incident: a Codex (OpenAI adapter) dispatch wrote a
- * modified tracked file to the MAIN repo instead of the isolated worktree, then:
- *   1. spawnBifrost never set CLAUDE_PROJECT_DIR / never captured
- *      originalWorktreeHead → detectWorktreeLeak NEVER fired for Bifrost.
- *   2. detectWorktreeLeak was WARN-ONLY: it wrote a marker + console.error but
- *      did NOT salvage the leaked content nor block the dispatch, so the file
- *      sat in the main working tree where a later force-checkout could discard
- *      it, and the dispatch was still reported as a clean success.
- *
- * This test drives the REAL detectWorktreeLeak (exported from runner.js) against
- * a synthetic temp repo + worktree (no external repo needed), simulating a
- * dispatch that produced ZERO task-branch commits while the main repo has an
- * uncommitted TRACKED modification. It asserts:
- *   • the leak is SALVAGED — recoverable on a branch, and
- *   • the dispatch is BLOCKED — child._formationExitCode flips to 1.
- *
- * Revert-proof: if the runner.js change (salvage + block) is reverted, this test
- * fails (no salvage branch / exit code stays 0).
- *
- * Scaffolding mirrors ./post-complete/worktree-rescue.test.js (TASK_1529).
- */
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const { detectWorktreeLeak } = require('./runner');
-
-function git(cmd, cwd) {
-  return execSync(cmd, { cwd, encoding: 'utf8', timeout: 20000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-}
-function gitSafe(cmd, cwd) {
-  try { return git(cmd, cwd); } catch { return null; }
-}
-
-function makeGitRepo(dir) {
-  git('git init', dir);
-  git('git config user.email "test@test.com"', dir);
-  git('git config user.name "Test"', dir);
-  git('git config commit.gpgsign false', dir);
-  gitSafe('git checkout -b userwork', dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'init\n');
-  git('git add README.md', dir);
-  git('git commit --no-verify -m "init"', dir);
-  const cur = git('git rev-parse --abbrev-ref HEAD', dir);
-  if (cur !== 'userwork') git(`git branch -m ${cur} userwork`, dir);
-}
-
-function setup() {
-  const tmpRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'tn1530-')));
-  const repo = path.join(tmpRoot, 'repo');
-  fs.mkdirSync(repo, { recursive: true });
-  makeGitRepo(repo);
-  return { tmpRoot, repo };
-}
-
-function teardown(tmpRoot, repo) {
-  try {
-    const wt = git('git worktree list --porcelain', repo);
-    for (const line of wt.split('\n')) {
-      if (line.startsWith('worktree ')) {
-        const p = line.slice('worktree '.length).trim();
-        if (p && path.resolve(p) !== path.resolve(repo)) {
-          gitSafe(`git worktree remove --force "${p}"`, repo);
-        }
-      }
-    }
-  } catch { /* best effort */ }
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// LEAK: zero task-branch commits + main repo has an uncommitted tracked change.
-// detectWorktreeLeak must SALVAGE the leaked change AND BLOCK the dispatch.
-// ─────────────────────────────────────────────────────────────────────────────
-
-test('TASK_1530: Bifrost write-leak (zero task commits + dirty main) is salvaged AND blocks dispatch', () => {
-  const { tmpRoot, repo } = setup();
-  try {
-    // Baseline tracked file the user cares about.
-    const lostContent = 'module.exports = { version: 2, critical: true };\n';
-    fs.writeFileSync(path.join(repo, 'kb.js'), 'module.exports = { version: 1 };\n');
-    git('git add kb.js', repo);
-    git('git commit --no-verify -m "seed kb.js baseline"', repo);
-
-    // Agent worktree on a task branch — snapshot HEAD BEFORE any agent work
-    // (exactly what spawnBifrost now captures as originalWorktreeHead).
-    const worktree = path.join(tmpRoot, 'wt');
-    git(`git worktree add -b task/task_repro1530 "${worktree}" HEAD`, repo);
-    const originalWorktreeHead = git('git rev-parse HEAD', worktree);
-
-    // THE BUG: the Codex agent produced ZERO commits on the task branch, and its
-    // modified tracked file landed in the MAIN repo (CLAUDE_PROJECT_DIR misroute).
-    fs.writeFileSync(path.join(repo, 'kb.js'), lostContent);
-
-    // Simulate runner.js's child object so the function can flip the exit code.
-    const child = { _formation: { sessionId: 'sess1530', skill: 'feature_agent' } };
-
-    // Drive the REAL detector against the synthetic repo (mainRoot = temp repo).
-    const res = detectWorktreeLeak(worktree, originalWorktreeHead, child, repo);
-
-    // 1) A leak must be reported.
-    assert.ok(res && res.leaked === true, `expected leak to be detected, got ${JSON.stringify(res)}`);
-
-    // 2) The dispatch must be BLOCKED: exit code flipped to 1.
-    assert.equal(child._formationExitCode, 1,
-      `expected child._formationExitCode=1 (blocked), got ${child._formationExitCode}`);
-    assert.ok(child._formationLeak, 'expected child._formationLeak to be set');
-
-    // 3) The leaked modification must be SALVAGED onto a recoverable branch.
-    assert.ok(res.salvageBranch, `expected a salvage branch, got ${res.salvageBranch}`);
-    const salvaged = gitSafe(`git show ${res.salvageBranch}:kb.js`, repo);
-    assert.equal(salvaged, lostContent.trim(),
-      `salvage branch must contain the leaked kb.js content. Got: ${JSON.stringify(salvaged)}`);
-
-    // 4) A LEAK_DETECTED marker is persisted in the worktree.
-    assert.ok(fs.existsSync(path.join(worktree, 'LEAK_DETECTED')), 'expected LEAK_DETECTED marker');
-  } finally {
-    teardown(tmpRoot, repo);
-  }
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// REGRESSION GUARD: a healthy dispatch (>=1 task-branch commit) must NOT be
-// flagged as a leak even if the main repo happens to be dirty.
-// ─────────────────────────────────────────────────────────────────────────────
-
-test('TASK_1530 regression: dispatch WITH task-branch commits is NOT flagged as leak', () => {
-  const { tmpRoot, repo } = setup();
-  try {
-    fs.writeFileSync(path.join(repo, 'kb.js'), 'v1\n');
-    git('git add kb.js', repo);
-    git('git commit --no-verify -m "seed"', repo);
-
-    const worktree = path.join(tmpRoot, 'wt');
-    git(`git worktree add -b task/task_ok1530 "${worktree}" HEAD`, repo);
-    const originalWorktreeHead = git('git rev-parse HEAD', worktree);
-
-    // Agent committed real work on the task branch (the healthy path).
-    fs.writeFileSync(path.join(worktree, 'feature.js'), 'export const x = 1;\n');
-    git('git add feature.js', worktree);
-    git('git commit --no-verify -m "[TASK_OK1530] add feature"', worktree);
-
-    // Main repo is incidentally dirty (e.g. unrelated state files).
-    fs.writeFileSync(path.join(repo, 'kb.js'), 'v1\nincidental\n');
-
-    const child = { _formation: { sessionId: 'sessok', skill: 'feature_agent' } };
-    const res = detectWorktreeLeak(worktree, originalWorktreeHead, child, repo);
-
-    assert.equal(res, null, `healthy dispatch must not be flagged as leak, got ${JSON.stringify(res)}`);
-    assert.equal(child._formationExitCode, undefined, 'exit code must remain unset for healthy dispatch');
-    assert.ok(!child._formationLeak, 'no leak record for healthy dispatch');
-  } finally {
-    teardown(tmpRoot, repo);
-  }
-});

package/core/k-cli/dist/alaya/run.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.status = status;
-exports.register = register;
-const output_1 = require("../core/output");
-// TASK_2361: Alaya device registration without the Dashboard Google login.
-//
-// Flow (RFC 8628 style, relay contract documented in TASK_2361):
-//   POST {relay}/auth/device/start -> {device_code, user_code, verification_url, interval, expires_in}
-//   user opens verification_url in any browser and approves (Google login at the relay)
-//   POST {relay}/auth/device/poll {device_code} -> 202 pending | 200 {token} | 410 expired | 403 denied
-// The JWT is handed to the local kenaz-server, which runs the one existing
-// register-device implementation (hub_client::register_alaya_device).
-// The JWT is held in memory only: never printed, never written.
-const server = () => process.env.KENAZ_SERVER_URL || `http://127.0.0.1:${process.env.KENAZ_HTTP_PORT || "18080"}`;
-const relay = () => (process.env.KENAZ_RELAY_URL || "https://app.kenazai.com").replace(/\/+$/, "");
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-const fail = (msg) => {
-    console.error(msg);
-    process.exit(1);
-};
-async function serverFetch(path, init) {
-    try {
-        return await fetch(`${server()}${path}`, init);
-    }
-    catch {
-        return fail(`Cannot reach kenaz-server at ${server()}. Start it first (kenaz-server or the Dashboard).`);
-    }
-}
-async function status(flags) {
-    const res = await serverFetch("/api/rust/alaya/status");
-    if (!res.ok)
-        fail(`kenaz-server returned ${res.status}`);
-    const s = (await res.json());
-    (0, output_1.output)(flags.json
-        ? s
-        : `Alaya: ${s.registered ? "registered" : "not registered"}; outbox depth: ${s.outbox_depth}` +
-            (s.registered ? "" : "\nRun: k-cli alaya register"), flags);
-}
-async function register(flags) {
-    const st = await serverFetch("/api/rust/alaya/status");
-    if (st.ok && (await st.json()).registered) {
-        (0, output_1.output)(flags.json ? { registered: true, already_registered: true } : "Alaya: already registered", flags);
-        return;
-    }
-    const start = await fetch(`${relay()}/auth/device/start`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: "{}",
-    }).catch((e) => fail(`Cannot reach relay ${relay()}: ${e.message}`));
-    if (start.status === 404) {
-        fail(`Relay ${relay()} has no device-code endpoint yet (POST /auth/device/start).\n` +
-            "Hub/relay change required; see TASK_2361 technical notes. Meanwhile, log in once via the Dashboard.");
-    }
-    if (!start.ok)
-        fail(`Relay device/start failed: HTTP ${start.status}`);
-    const d = (await start.json());
-    console.log(`Open ${d.verification_url} in any browser and enter code: ${d.user_code}`);
-    const deadline = Date.now() + (d.expires_in ?? 600) * 1000;
-    const intervalMs = Math.max(1, d.interval ?? 5) * 1000;
-    let token = "";
-    while (Date.now() < deadline) {
-        await sleep(intervalMs);
-        const p = await fetch(`${relay()}/auth/device/poll`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ device_code: d.device_code }),
-        }).catch(() => null);
-        if (!p || p.status === 202 || p.status === 428)
-            continue;
-        if (p.status === 403)
-            fail("Approval denied.");
-        if (p.status === 410)
-            fail("Code expired. Run the command again.");
-        if (!p.ok)
-            fail(`Relay device/poll failed: HTTP ${p.status}`);
-        token = (await p.json()).token ?? "";
-        break;
-    }
-    if (!token)
-        fail("Timed out waiting for approval.");
-    const r = await serverFetch("/api/rust/alaya/register", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ token }),
-    });
-    const res = (await r.json().catch(() => ({})));
-    if (!r.ok || !res.registered)
-        fail(`Registration failed: ${res.error ?? `HTTP ${r.status}`}`);
-    (0, output_1.output)(flags.json ? res : "Alaya: registered (~/.kenaz/alaya.toml written); queued reports will drain", flags);
-}

package/core/k-cli/dist/core/output.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatTable = formatTable;
-exports.output = output;
-function formatTable(headers, rows) {
-    const colWidths = headers.map((h, i) => {
-        const vals = [h, ...rows.map((r) => String(r[i] || ""))];
-        return Math.max(...vals.map((v) => v.length));
-    });
-    const sep = colWidths.map((w) => "-".repeat(w + 2)).join("+");
-    const line = (cells) => cells.map((c, i) => ` ${String(c).padEnd(colWidths[i])} `).join("|");
-    return [line(headers), sep, ...rows.map((r) => line(r))].join("\n");
-}
-function output(data, opts = {}) {
-    if (opts.json) {
-        console.log(JSON.stringify(data, null, 2));
-    }
-    else if (typeof data === "string") {
-        console.log(data);
-    }
-    else {
-        console.log(JSON.stringify(data, null, 2));
-    }
-}

package/core/k-cli/dist/core/process.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeProcess = nodeProcess;
-const child_process_1 = require("child_process");
-/**
- * Spawn a process and return stdout.
- * cmd defaults to node (process.execPath).
- * shell defaults to false to avoid Windows arg escaping issues.
- */
-function nodeProcess(args, cwd, timeout = 10000, cmd = process.execPath, shell = false) {
-    return new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(cmd, args, {
-            cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true,
-            shell,
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (d) => (stdout += d));
-        child.stderr.on("data", (d) => (stderr += d));
-        const timer = setTimeout(() => {
-            child.kill();
-            reject(new Error("timeout"));
-        }, timeout);
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            if (code !== 0)
-                reject(new Error(stderr || `exit code ${code}`));
-            else
-                resolve(stdout.trim());
-        });
-        child.on("error", (e) => {
-            clearTimeout(timer);
-            reject(e);
-        });
-    });
-}

package/core/k-cli/dist/core/project.js

@@ -1,80 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveProject = resolveProject;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const yaml = __importStar(require("yaml"));
-function resolveProject(explicitPath) {
-    const cwd = path.resolve(explicitPath || process.cwd());
-    const isCore = fs.existsSync(path.join(cwd, ".collaboration", "tasks"));
-    const kenazYaml = path.join(cwd, ".kenaz", "project.yaml");
-    const hasKenaz = fs.existsSync(kenazYaml);
-    // Read .kenaz/project.yaml if it exists
-    let config = null;
-    if (hasKenaz) {
-        const raw = fs.readFileSync(kenazYaml, "utf-8");
-        config = yaml.parse(raw);
-    }
-    // Core project (has .collaboration/tasks)
-    if (isCore) {
-        return {
-            mode: "core",
-            name: config?.project_name || path.basename(cwd),
-            path: cwd,
-            core_path: cwd,
-            config,
-        };
-    }
-    // Sub-project (has .kenaz/project.yaml but no .collaboration/tasks)
-    if (hasKenaz && config) {
-        const corePath = path.resolve(config.core_path || cwd);
-        return {
-            mode: "sub-project",
-            name: config.project_name || path.basename(cwd),
-            path: cwd,
-            core_path: corePath,
-            config,
-        };
-    }
-    // Unknown — no detection, no guessing
-    return {
-        mode: "unknown",
-        name: path.basename(cwd),
-        path: cwd,
-        core_path: cwd,
-        config: null,
-    };
-}

package/core/k-cli/dist/core/spawn.js

@@ -1,268 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.spawnClaude = spawnClaude;
-exports.collectClaudeOutput = collectClaudeOutput;
-exports.streamClaudeOutput = streamClaudeOutput;
-const child_process_1 = require("child_process");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-/**
- * Detect git-bash path on Windows.
- * Claude Code requires git-bash to run on Windows.
- */
-function detectGitBash() {
-    try {
-        const gitPaths = (0, child_process_1.execSync)("where git", { encoding: "utf8", timeout: 5000, windowsHide: true })
-            .split("\n").map((l) => l.trim()).filter(Boolean);
-        for (const gitPath of gitPaths) {
-            let dir = path.dirname(gitPath);
-            for (let i = 0; i < 4; i++) {
-                const bashPath = path.join(dir, "bin", "bash.exe");
-                if (fs.existsSync(bashPath))
-                    return bashPath;
-                dir = path.dirname(dir);
-            }
-        }
-    }
-    catch { }
-    const fallbacks = [
-        "C:\\Program Files\\Git\\bin\\bash.exe",
-        "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
-        "D:\\Program Files\\Git\\bin\\bash.exe",
-    ];
-    for (const p of fallbacks) {
-        if (fs.existsSync(p))
-            return p;
-    }
-    return null;
-}
-/**
- * Detect the claude CLI command path.
- */
-function detectClaudeCmd() {
-    if (process.platform !== "win32")
-        return "claude";
-    try {
-        const result = (0, child_process_1.execSync)("where claude", { encoding: "utf8", timeout: 5000, windowsHide: true })
-            .split("\n").map((l) => l.trim()).filter(Boolean);
-        if (result.length > 0) {
-            return result.find((p) => p.endsWith(".cmd")) || result[0];
-        }
-    }
-    catch { }
-    const homedir = process.env.USERPROFILE || process.env.HOME || "";
-    const candidates = [
-        path.join(homedir, ".claude", "local", "claude.exe"),
-        path.join(homedir, ".claude", "bin", "claude.exe"),
-    ];
-    for (const p of candidates) {
-        if (fs.existsSync(p))
-            return p;
-    }
-    return "claude.cmd";
-}
-/**
- * Build a clean env for Claude subprocesses.
- * Mirrors .formation/tools/utils.js getClaudeEnv()
- */
-function getClaudeEnv() {
-    const env = { ...process.env };
-    // Remove CLAUDECODE to avoid nested session error
-    delete env.CLAUDECODE;
-    // Windows: ensure git-bash path is set
-    if (process.platform === "win32" && !env.CLAUDE_CODE_GIT_BASH_PATH) {
-        const gitBash = detectGitBash();
-        if (gitBash)
-            env.CLAUDE_CODE_GIT_BASH_PATH = gitBash;
-    }
-    return env;
-}
-/**
- * Spawn a Claude CLI subprocess.
- *
- * Returns the ChildProcess. Caller is responsible for
- * listening on stdout/stderr/close events.
- */
-function spawnClaude(opts) {
-    const { prompt, cwd, allowedTools = "Bash,Read,Edit,Write,Glob,Grep", disallowedTools, extraArgs = [], projectPath = null, } = opts;
-    const claudeCmd = detectClaudeCmd();
-    const args = [
-        "-p", "-",
-        "--dangerously-skip-permissions",
-        "--output-format", "stream-json",
-        "--verbose",
-        "--allowedTools", allowedTools,
-        ...(disallowedTools ? ["--disallowedTools", disallowedTools] : []),
-        ...extraArgs,
-    ];
-    const env = getClaudeEnv();
-    // Sub-project git isolation
-    if (projectPath && projectPath !== cwd) {
-        const parentDir = path.dirname(projectPath);
-        env.GIT_CEILING_DIRECTORIES = parentDir;
-    }
-    const child = (0, child_process_1.spawn)(claudeCmd, args, {
-        cwd: projectPath || cwd,
-        env,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        shell: true,
-    });
-    child.stdin.write(prompt, "utf8");
-    child.stdin.end();
-    return child;
-}
-/**
- * Format a tool_use block into a concise one-liner.
- */
-function formatToolUse(block) {
-    const name = block.name || "unknown";
-    const input = block.input || {};
-    // Extract the most relevant field for each tool type
-    if (name === "Bash" && input.command) {
-        const cmd = String(input.command);
-        const short = cmd.length > 120 ? cmd.slice(0, 120) + "..." : cmd;
-        return `[${name}] ${short}`;
-    }
-    if ((name === "Read" || name === "Write") && input.file_path) {
-        return `[${name}] ${input.file_path}`;
-    }
-    if (name === "Edit" && input.file_path) {
-        return `[${name}] ${input.file_path}`;
-    }
-    if ((name === "Glob" || name === "Grep") && input.pattern) {
-        return `[${name}] ${input.pattern}`;
-    }
-    // Fallback: tool name + first string value
-    const firstVal = Object.values(input).find((v) => typeof v === "string");
-    return firstVal ? `[${name}] ${String(firstVal).slice(0, 80)}` : `[${name}]`;
-}
-/**
- * Collect Claude stream-json stdout as a string (no console output).
- * Used when the caller needs to parse the result programmatically.
- */
-function collectClaudeOutput(child) {
-    return new Promise((resolve, reject) => {
-        let stderr = "";
-        let result = "";
-        child.stdout.on("data", (d) => {
-            const lines = d.toString().split("\n").filter((l) => l.trim());
-            for (const line of lines) {
-                try {
-                    const evt = JSON.parse(line);
-                    if (evt.type === "assistant" && evt.message?.content) {
-                        for (const block of evt.message.content) {
-                            if (block.type === "text" && block.text) {
-                                result += block.text;
-                            }
-                        }
-                    }
-                    else if (evt.type === "result" && typeof evt.result === "string") {
-                        result += evt.result;
-                    }
-                }
-                catch {
-                    // not JSON — skip
-                }
-            }
-        });
-        child.stderr.on("data", (d) => (stderr += d));
-        child.on("close", (code) => {
-            if (code !== 0) {
-                reject(new Error(`Claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
-                return;
-            }
-            resolve(result);
-        });
-        child.on("error", (e) => reject(e));
-    });
-}
-/**
- * Parse Claude stream-json stdout and output formatted content.
- * - text blocks: output as-is
- * - tool_use blocks: formatted one-liner showing what the agent is doing
- * - thinking, raw JSON: filtered out
- */
-function streamClaudeOutput(child) {
-    return new Promise((resolve, reject) => {
-        let stderr = "";
-        let hasOutput = false;
-        child.stdout.on("data", (d) => {
-            const lines = d.toString().split("\n").filter((l) => l.trim());
-            for (const line of lines) {
-                try {
-                    const evt = JSON.parse(line);
-                    if (evt.type === "assistant" && evt.message?.content) {
-                        for (const block of evt.message.content) {
-                            if (block.type === "text" && block.text) {
-                                hasOutput = true;
-                                process.stdout.write(block.text);
-                            }
-                            else if (block.type === "tool_use") {
-                                hasOutput = true;
-                                console.log(formatToolUse(block));
-                            }
-                        }
-                    }
-                    else if (evt.type === "result" && evt.result) {
-                        hasOutput = true;
-                        console.log(evt.result);
-                    }
-                }
-                catch {
-                    // not JSON — skip
-                }
-            }
-        });
-        child.stderr.on("data", (d) => (stderr += d));
-        child.on("close", (code) => {
-            if (code !== 0) {
-                console.error(`\nError: Claude exited with code ${code}`);
-                if (stderr)
-                    console.error(stderr);
-                process.exit(1);
-            }
-            if (!hasOutput) {
-                console.error("\nWarning: Claude exited successfully but produced no output.", "\nThis may indicate nested session detection.", stderr ? `\nStderr: ${stderr.slice(0, 500)}` : "");
-            }
-            resolve();
-        });
-        child.on("error", (e) => {
-            console.error(`Error spawning Claude: ${e.message}`);
-            reject(e);
-        });
-    });
-}

package/core/k-cli/dist/core/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });