@golba98/codexa 1.0.2 → 1.0.3

package/src/core/perf/renderDebug.test.ts

@@ -1,230 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import test from "node:test";
-import {
-  configureRenderDebug,
-  getRenderDebugLogPath,
-  traceBlankFrame,
-  traceEvent,
-  traceLayoutValidity,
-  traceLifecycleEvent,
-  traceLifecycleTransition,
-  traceFlickerEvent,
-  traceStatusTick,
-  traceRender,
-  traceTerminalWrite,
-} from "./renderDebug.js";
-
-function clean(path: string): void {
-  rmSync(path, { force: true });
-}
-
-test("render debug stays quiet by default", () => {
-  const logPath = join(tmpdir(), `codexa-render-debug-quiet-${process.pid}.jsonl`);
-  clean(logPath);
-
-  configureRenderDebug({ CODEXA_RENDER_DEBUG_FILE: logPath });
-  traceEvent("test", "quiet");
-  traceRender("QuietComponent", "test");
-
-  assert.equal(existsSync(logPath), false);
-});
-
-test("render debug writes JSONL only when explicitly enabled", () => {
-  const logPath = join(tmpdir(), `codexa-render-debug-enabled-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_RENDER_DEBUG: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceRender("EnabledComponent", "unit");
-
-    assert.equal(getRenderDebugLogPath(), logPath);
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records[0]?.kind, "session");
-    assert.equal(records[1]?.kind, "render");
-    assert.equal(records[1]?.component, "EnabledComponent");
-    assert.equal(records[1]?.reason, "unit");
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});
-
-test("render debug defaults to the repo-local diagnostic log path", () => {
-  configureRenderDebug({});
-  assert.equal(getRenderDebugLogPath(), join(process.cwd(), ".codexa-debug", "render-debug.log"));
-});
-
-test("render debug creates missing log directories", () => {
-  const logPath = join(tmpdir(), `codexa-render-debug-nested-${process.pid}`, "render-debug.log");
-  rmSync(join(tmpdir(), `codexa-render-debug-nested-${process.pid}`), { force: true, recursive: true });
-
-  try {
-    configureRenderDebug({
-      CODEXA_RENDER_DEBUG: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    assert.equal(existsSync(logPath), true);
-  } finally {
-    configureRenderDebug({});
-    rmSync(join(tmpdir(), `codexa-render-debug-nested-${process.pid}`), { force: true, recursive: true });
-  }
-});
-
-test("render debug records lifecycle, layout, and blank-frame diagnostics", () => {
-  const logPath = join(tmpdir(), `codexa-render-diagnostics-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_RENDER_DEBUG: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceLifecycleEvent("Timeline", "mount", { viewportRows: 12 });
-    traceLayoutValidity("Timeline", { viewportRows: 0, cols: 120 });
-    traceBlankFrame("Timeline", { reason: "visible-rows-zero-with-events" });
-
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records[1]?.kind, "lifecycle");
-    assert.equal(records[1]?.component, "Timeline");
-    assert.equal(records[1]?.event, "mount");
-    assert.equal(records[2]?.kind, "layout");
-    assert.equal(records[2]?.event, "invalidLayout");
-    assert.deepEqual(records[2]?.invalidValues, [{ key: "viewportRows", value: 0 }]);
-    assert.equal(records[3]?.kind, "blankFrame");
-    assert.equal(records[3]?.reason, "visible-rows-zero-with-events");
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});
-
-test("terminal writes are classified for clear and reset diagnosis", () => {
-  const logPath = join(tmpdir(), `codexa-terminal-classification-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_RENDER_DEBUG: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceTerminalWrite(
-      "stdout",
-      "unit",
-      "\x1b[2J\x1b[3J\x1b[H\x1bc\x1b[?1049h\x1b]0;CODEXA\x07\x1b[?2004h\x1b[?1000h",
-    );
-
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records[1]?.kind, "stdout");
-    assert.equal(records[1]?.containsViewportClear, true);
-    assert.equal(records[1]?.containsScrollbackClear, true);
-    assert.equal(records[1]?.containsCursorHome, true);
-    assert.equal(records[1]?.containsTerminalReset, true);
-    assert.equal(records[1]?.containsAlternateScreen, true);
-    assert.equal(records[1]?.containsTitleSequence, true);
-    assert.equal(records[1]?.containsBracketedPaste, true);
-    assert.equal(records[1]?.containsMouseMode, true);
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});
-
-test("CODEXA_DEBUG_RENDER aliases render debug logging", () => {
-  const logPath = join(tmpdir(), `codexa-debug-render-alias-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_DEBUG_RENDER: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceRender("AliasComponent", "unit");
-
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records[0]?.kind, "session");
-    assert.equal(records[1]?.kind, "render");
-    assert.equal(records[1]?.component, "AliasComponent");
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});
-
-test("render trace flag enables compact render diagnostics", () => {
-  const logPath = join(tmpdir(), `codexa-render-trace-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_DEBUG_RENDER_TRACE: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceRender("TraceComponent", "unit");
-    traceFlickerEvent("viewportSlice", { reason: "unit" });
-
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records[0]?.kind, "session");
-    assert.equal(records[1]?.kind, "render");
-    assert.equal(records[1]?.component, "TraceComponent");
-    assert.equal(records[2]?.kind, "flicker");
-    assert.equal(records[2]?.event, "viewportSlice");
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});
-
-test("lifecycle trace is gated by CODEXA_DEBUG_LIFECYCLE", () => {
-  const logPath = join(tmpdir(), `codexa-lifecycle-debug-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_DEBUG_LIFECYCLE: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceLifecycleTransition({
-      prevKind: "THINKING",
-      nextKind: "IDLE",
-      reason: "unit",
-    });
-
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records.length, 1);
-    assert.equal(records[0]?.kind, "lifecycle");
-    assert.equal(records[0]?.reason, "unit");
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});
-
-test("flicker trace is gated by CODEXA_DEBUG_FLICKER", () => {
-  const logPath = join(tmpdir(), `codexa-flicker-debug-${process.pid}.jsonl`);
-  clean(logPath);
-
-  try {
-    configureRenderDebug({
-      CODEXA_DEBUG_FLICKER: "1",
-      CODEXA_RENDER_DEBUG_FILE: logPath,
-    });
-    traceFlickerEvent("timelineRender", { reason: "unit" });
-    traceStatusTick({ owner: "Status", label: "Codex is thinking" });
-
-    const records = readFileSync(logPath, "utf8").trim().split("\n").map((line) => JSON.parse(line));
-    assert.equal(records.length, 2);
-    assert.equal(records[0]?.kind, "flicker");
-    assert.equal(records[0]?.event, "timelineRender");
-    assert.equal(records[1]?.kind, "flicker");
-    assert.equal(records[1]?.event, "statusTick");
-  } finally {
-    configureRenderDebug({});
-    clean(logPath);
-  }
-});

package/src/core/planStorage.test.ts

@@ -1,143 +0,0 @@
-import assert from "node:assert/strict";
-import test, { afterEach, beforeEach, describe } from "node:test";
-import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { resolvePlanDir, savePlan, readPlan } from "./planStorage.js";
-
-describe("resolvePlanDir", () => {
-  const savedEnv: Record<string, string | undefined> = {};
-  const envKeys = ["CODEXA_PLAN_DIR", "LOCALAPPDATA", "APPDATA", "XDG_DATA_HOME"];
-
-  beforeEach(() => {
-    for (const key of envKeys) {
-      savedEnv[key] = process.env[key];
-    }
-  });
-
-  afterEach(() => {
-    for (const key of envKeys) {
-      if (savedEnv[key] === undefined) {
-        delete process.env[key];
-      } else {
-        process.env[key] = savedEnv[key];
-      }
-    }
-  });
-
-  test("CODEXA_PLAN_DIR override takes priority", () => {
-    process.env["CODEXA_PLAN_DIR"] = "/custom/plan/dir";
-    assert.equal(resolvePlanDir(), "/custom/plan/dir");
-  });
-
-  test("Windows LOCALAPPDATA path resolution", () => {
-    delete process.env["CODEXA_PLAN_DIR"];
-    process.env["LOCALAPPDATA"] = "C:\\Users\\test\\AppData\\Local";
-    const result = resolvePlanDir("win32");
-    assert.ok(result.includes("Codexa"));
-    assert.ok(result.includes("plans"));
-    assert.ok(result.includes("AppData"));
-  });
-
-  test("Windows APPDATA fallback", () => {
-    delete process.env["CODEXA_PLAN_DIR"];
-    delete process.env["LOCALAPPDATA"];
-    process.env["APPDATA"] = "C:\\Users\\test\\AppData\\Roaming";
-    const result = resolvePlanDir("win32");
-    assert.ok(result.includes("Codexa"));
-    assert.ok(result.includes("plans"));
-    assert.ok(result.includes("Roaming"));
-  });
-
-  test("macOS path", () => {
-    delete process.env["CODEXA_PLAN_DIR"];
-    const result = resolvePlanDir("darwin");
-    assert.ok(result.includes("Library"));
-    assert.ok(result.includes("Codexa"));
-    assert.ok(result.includes("plans"));
-  });
-
-  test("Linux default path", () => {
-    delete process.env["CODEXA_PLAN_DIR"];
-    delete process.env["XDG_DATA_HOME"];
-    const result = resolvePlanDir("linux");
-    assert.ok(result.includes(".local"));
-    assert.ok(result.includes("share"));
-    assert.ok(result.includes("codexa"));
-    assert.ok(result.includes("plans"));
-  });
-
-  test("Linux XDG_DATA_HOME override", () => {
-    delete process.env["CODEXA_PLAN_DIR"];
-    process.env["XDG_DATA_HOME"] = "/custom/xdg/data";
-    const result = resolvePlanDir("linux");
-    assert.ok(result.includes("custom"));
-    assert.ok(result.includes("xdg"));
-    assert.ok(result.includes("codexa"));
-    assert.ok(result.includes("plans"));
-  });
-});
-
-describe("savePlan", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = join(tmpdir(), `planStorage-test-${Date.now()}`);
-    mkdirSync(tempDir, { recursive: true });
-    process.env["CODEXA_PLAN_DIR"] = tempDir;
-  });
-
-  afterEach(() => {
-    delete process.env["CODEXA_PLAN_DIR"];
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  test("safe filename format with timestamp and 8-hex-char hash", () => {
-    const result = savePlan("# My Plan", "/some/workspace");
-    assert.notEqual(result, null);
-    const filename = result!.split(/[/\\]/).pop()!;
-    assert.match(filename, /^plan-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}.*-[0-9a-f]{8}\.md$/);
-  });
-
-  test("written content can be read back", () => {
-    const content = "# Test Plan\n\n- Step 1\n- Step 2\n";
-    const result = savePlan(content, "/workspace");
-    assert.notEqual(result, null);
-    assert.ok(existsSync(result!));
-    assert.equal(readPlan(result!), content);
-  });
-
-  test("write failure returns null", () => {
-    process.env["CODEXA_PLAN_DIR"] = "/nonexistent\x00/bad/path";
-    const result = savePlan("content", "/workspace");
-    assert.equal(result, null);
-  });
-
-  test("does not write to process.cwd()", () => {
-    const cwdPlanDir = join(process.cwd(), ".codexa");
-    const beforeMarkdown = existsSync(cwdPlanDir)
-      ? readdirSync(cwdPlanDir).filter((name) => name.endsWith(".md")).sort()
-      : [];
-    savePlan("# Plan", process.cwd());
-    const afterMarkdown = existsSync(cwdPlanDir)
-      ? readdirSync(cwdPlanDir).filter((name) => name.endsWith(".md")).sort()
-      : [];
-    assert.deepEqual(afterMarkdown, beforeMarkdown);
-  });
-});
-
-describe("readPlan", () => {
-  test("returns null for missing file", () => {
-    assert.equal(readPlan("/nonexistent/file.md"), null);
-  });
-
-  test("reads existing file content", () => {
-    const tempFile = join(tmpdir(), `plan-read-test-${Date.now()}.md`);
-    writeFileSync(tempFile, "hello plan", "utf-8");
-    try {
-      assert.equal(readPlan(tempFile), "hello plan");
-    } finally {
-      rmSync(tempFile, { force: true });
-    }
-  });
-});

package/src/core/process/CommandRunner.test.ts

@@ -1,105 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-import { runCommand, runShellCommand, summarizeCommandResult, type CommandResult } from "./CommandRunner.js";
-
-function makeResult(overrides: Partial<CommandResult> = {}): CommandResult {
-  return {
-    status: "completed",
-    exitCode: 0,
-    signal: null,
-    stdout: "",
-    stderr: "",
-    startedAt: 1,
-    endedAt: 2,
-    durationMs: 1,
-    userMessage: "Command completed.",
-    ...overrides,
-  };
-}
-
-test("summarizes ripgrep file listings without flooding the UI", () => {
-  const result = makeResult({
-    stdout: "src/app.tsx\nsrc/ui/BottomComposer.tsx\n",
-  });
-
-  assert.equal(summarizeCommandResult("rg --files", result), "Found 2 files.");
-});
-
-test("keeps a concise fallback summary for generic successful commands", () => {
-  const result = makeResult({
-    stdout: "alpha\nbeta\ngamma\n",
-  });
-
-  assert.equal(summarizeCommandResult("node script.js", result), "Produced 3 lines of output.");
-});
-
-test("preserves the failure message for unsuccessful commands", () => {
-  const result = makeResult({
-    status: "failed",
-    exitCode: 1,
-    userMessage: "git exited with code 1.",
-    stderr: "fatal: not a git repository",
-  });
-
-  assert.equal(summarizeCommandResult("git status", result), "git exited with code 1.");
-});
-
-test("runCommand executes a direct executable with argument array", async () => {
-  const runner = runCommand({
-    executable: process.execPath,
-    args: ["-e", "console.log(process.argv[1])", "direct-ok"],
-    cwd: process.cwd(),
-  });
-
-  const result = await runner.result;
-  assert.equal(result.status, "completed");
-  assert.equal(result.exitCode, 0);
-  assert.equal(result.stdout.trim(), "direct-ok");
-});
-
-test("runCommand rejects obvious executable injection", () => {
-  assert.throws(
-    () => runCommand({
-      executable: "node & echo injected",
-      args: ["--version"],
-      cwd: process.cwd(),
-    }),
-    /single executable name|shell metacharacters/i,
-  );
-});
-
-test("runShellCommand is the explicit shell execution path", async () => {
-  const runner = runShellCommand("echo shell-ok", { cwd: process.cwd() });
-  const result = await runner.result;
-
-  assert.equal(result.status, "completed");
-  assert.equal(result.exitCode, 0);
-  assert.match(result.stdout, /shell-ok/);
-});
-
-test("command runner reports lifecycle boundaries for terminal title reassertion", () => {
-  const source = readFileSync(fileURLToPath(new URL("./CommandRunner.ts", import.meta.url)), "utf8");
-  const beforeSpawnIndex = source.indexOf('handlers.onProcessLifecycle?.("before-spawn")');
-  const spawnIndex = source.indexOf("child = spawn(");
-  const spawnedIndex = source.indexOf('handlers.onProcessLifecycle?.("spawned")', spawnIndex);
-  const errorIndex = source.indexOf('child.once("error"', spawnIndex);
-  const lifecycleErrorIndex = source.indexOf('handlers.onProcessLifecycle?.("error")', errorIndex);
-  const closeIndex = source.indexOf('child.once("close"', spawnIndex);
-  const exitIndex = source.indexOf('handlers.onProcessLifecycle?.("exit")', closeIndex);
-  const cancelIndex = source.indexOf("cancel: () =>");
-  const lifecycleCancelIndex = source.indexOf('handlers.onProcessLifecycle?.("cancel")', cancelIndex);
-
-  assert.ok(beforeSpawnIndex >= 0 && beforeSpawnIndex < spawnIndex);
-  assert.ok(spawnedIndex > spawnIndex);
-  assert.ok(lifecycleErrorIndex > errorIndex);
-  assert.ok(exitIndex > closeIndex);
-  assert.ok(lifecycleCancelIndex > cancelIndex);
-});
-
-test("generic command runner does not expose shell mode", () => {
-  const source = readFileSync(fileURLToPath(new URL("./CommandRunner.ts", import.meta.url)), "utf8");
-  assert.equal(source.includes("shell?: boolean"), false);
-  assert.equal(source.includes("spec.shell"), false);
-});

package/src/core/projectInstructions.test.ts

@@ -1,50 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import { loadProjectInstructions } from "./projectInstructions.js";
-
-function withTempWorkspace(run: (workspaceRoot: string) => void) {
-  const workspaceRoot = mkdtempSync(join(tmpdir(), "codexa-instructions-"));
-  try {
-    run(workspaceRoot);
-  } finally {
-    rmSync(workspaceRoot, { recursive: true, force: true });
-  }
-}
-
-test("loads AGENTS.md from the workspace root first", () => {
-  withTempWorkspace((workspaceRoot) => {
-    mkdirSync(join(workspaceRoot, ".codex"), { recursive: true });
-    writeFileSync(join(workspaceRoot, "AGENTS.md"), "root instructions\n", "utf8");
-    writeFileSync(join(workspaceRoot, ".codex", "AGENTS.md"), "nested instructions\n", "utf8");
-
-    const result = loadProjectInstructions(workspaceRoot);
-
-    assert.equal(result.status, "loaded");
-    if (result.status !== "loaded") return;
-    assert.equal(result.instructions.content, "root instructions");
-    assert.match(result.instructions.path, /AGENTS\.md$/);
-  });
-});
-
-test("falls back to .codex/AGENTS.md", () => {
-  withTempWorkspace((workspaceRoot) => {
-    mkdirSync(join(workspaceRoot, ".codex"), { recursive: true });
-    writeFileSync(join(workspaceRoot, ".codex", "AGENTS.md"), "project instructions\n", "utf8");
-
-    const result = loadProjectInstructions(workspaceRoot);
-
-    assert.equal(result.status, "loaded");
-    if (result.status !== "loaded") return;
-    assert.equal(result.instructions.content, "project instructions");
-    assert.match(result.instructions.path, /\.codex[\\/]AGENTS\.md$/);
-  });
-});
-
-test("treats missing instruction files as non-fatal", () => {
-  withTempWorkspace((workspaceRoot) => {
-    assert.deepEqual(loadProjectInstructions(workspaceRoot), { status: "missing" });
-  });
-});