@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/caveman/index.js

@@ -0,0 +1,116 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const { getCavemanInstructions } = require("./caveman-instructions.cjs");
+
+export { getCavemanInstructions };
+
+export function resolveSessionActive(entries, fallback = true) {
+  if (!Array.isArray(entries)) return fallback;
+
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry?.type !== "custom" || entry?.customType !== "caveman-mode") continue;
+
+    const active = entry?.data?.active;
+    if (typeof active === "boolean") return active;
+  }
+
+  return fallback;
+}
+
+export function parseCavemanCommand(text) {
+  const normalizedText = String(text || "").trim().toLowerCase();
+  if (!normalizedText) return { type: "toggle" };
+
+  const [primary] = normalizedText.split(/\s+/);
+  if (primary === "status") return { type: "status" };
+  if (primary === "on" || primary === "enable") return { type: "set", active: true };
+  if (primary === "off" || primary === "disable") return { type: "set", active: false };
+  return { type: "invalid", reason: "unknown-subcommand", arg: primary };
+}
+
+export function isDeactivationCommand(text) {
+  const t = String(text || "").trim().toLowerCase().replace(/[.!?\s]+$/, "");
+  return t === "stop caveman" || t === "normal mode";
+}
+
+export default function cavemanExtension(pi) {
+  let active = true;
+  let isActive = false;
+  let lastCtx = null;
+
+  function syncStatus(ctx) {
+    if (ctx) lastCtx = ctx;
+    const c = ctx || lastCtx;
+    if (!c?.ui?.setStatus || !c.ui.theme?.fg) return;
+    const theme = c.ui.theme;
+    if (!active) {
+      c.ui.setStatus("caveman", "");
+      return;
+    }
+    const indicator = isActive ? theme.fg("accent", "●") : theme.fg("dim", "○");
+    c.ui.setStatus("caveman", indicator + " 🦴 " + theme.fg("muted", "caveman: ") + theme.fg("text", active ? "ON" : "OFF"));
+  }
+
+  const setActive = (value, ctx) => {
+    active = Boolean(value);
+    pi.appendEntry("caveman-mode", { active });
+    syncStatus(ctx);
+    ctx?.ui?.notify?.(`Caveman mode ${active ? "enabled" : "disabled"}.`, "info");
+  };
+
+  pi.registerCommand("caveman", {
+    description: "Toggle or report Caveman mode",
+    handler: async (args, ctx) => {
+      const parsed = parseCavemanCommand(args);
+
+      if (parsed.type === "status") {
+        ctx?.ui?.notify?.(`Caveman: ${active ? "ON" : "OFF"}`, "info");
+        return;
+      }
+
+      if (parsed.type === "toggle") {
+        setActive(!active, ctx);
+        return;
+      }
+
+      if (parsed.type === "set") {
+        setActive(parsed.active, ctx);
+        return;
+      }
+
+      ctx?.ui?.notify?.("Unknown /caveman subcommand. Use: on, off, status.", "warning");
+    },
+  });
+
+  pi.on("input", async (event) => {
+    if (event?.source === "extension") return;
+    const text = String(event?.text || "");
+    if (active && isDeactivationCommand(text)) {
+      setActive(false);
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+    active = resolveSessionActive(entries, true);
+    syncStatus(ctx);
+    ctx?.ui?.notify?.(`Caveman loaded: ${active ? "ON" : "OFF"}`, "info");
+  });
+
+  pi.on("agent_start", async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    if (!active) return;
+    return { systemPrompt: `${event.systemPrompt}\n\n${getCavemanInstructions()}` };
+  });
+}

package/dist/extensions/caveman/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "caveman",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test ./test/*.test.js"
+  }
+}

package/dist/extensions/caveman/test/extension.test.js

@@ -0,0 +1,185 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import cavemanExtension from "../index.js";
+
+function createPiHarness() {
+  const events = new Map();
+  const commands = new Map();
+  const appendedEntries = [];
+  const sentUserMessages = [];
+
+  const pi = {
+    on(eventName, handler) { events.set(eventName, handler); },
+    registerCommand(name, options) { commands.set(name, options); },
+    appendEntry(customType, data) { appendedEntries.push({ customType, data }); },
+    sendUserMessage(text, options) { sentUserMessages.push({ text, options }); },
+  };
+
+  cavemanExtension(pi);
+  return { events, commands, appendedEntries, sentUserMessages };
+}
+
+function createCommandContext(overrides = {}) {
+  return {
+    isIdle: () => true,
+    sessionManager: { getEntries: () => [] },
+    ui: { notify() {} },
+    ...overrides,
+  };
+}
+
+test("extension registers the /caveman command", () => {
+  const { commands } = createPiHarness();
+  assert.deepEqual([...commands.keys()], ["caveman"]);
+});
+
+test("/caveman on/off appends a caveman-mode entry", async () => {
+  const { commands, events, appendedEntries } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("caveman").handler("off", ctx);
+
+  assert.deepEqual(appendedEntries.at(-1), { customType: "caveman-mode", data: { active: false } });
+
+  await commands.get("caveman").handler("on", ctx);
+  assert.deepEqual(appendedEntries.at(-1), { customType: "caveman-mode", data: { active: true } });
+});
+
+test("bare /caveman toggles off then back on", async () => {
+  const { commands, events, appendedEntries } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx); // starts on
+  await commands.get("caveman").handler("", ctx);
+  assert.equal(appendedEntries.at(-1).data.active, false);
+  await commands.get("caveman").handler("", ctx);
+  assert.equal(appendedEntries.at(-1).data.active, true);
+});
+
+test("before_agent_start injects instructions while active", async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.ok(result.systemPrompt.startsWith("BASE"));
+  assert.ok(result.systemPrompt.includes("CAVEMAN MODE ACTIVE"));
+});
+
+test("disabled caveman skips instruction injection", async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("caveman").handler("off", ctx);
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.equal(result, undefined);
+});
+
+test("session_start restores latest persisted active flag", async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext({
+    sessionManager: {
+      getEntries: () => [
+        { type: "custom", customType: "caveman-mode", data: { active: false } },
+      ],
+    },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.equal(result, undefined); // persisted false -> no injection
+});
+
+test("'stop caveman' as a whole message deactivates mid-session", async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await events.get("input")({ text: "stop caveman", source: "interactive" }, ctx);
+
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.equal(result, undefined);
+});
+
+test("a request merely mentioning 'stop caveman' stays active", async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await events.get("input")({ text: "how do I stop caveman re-rendering?", source: "interactive" }, ctx);
+
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.ok(result.systemPrompt.includes("CAVEMAN MODE ACTIVE"));
+});
+
+test("status bar renders ON and flips active on agent_start", async () => {
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [] },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_c, t) => t } },
+  });
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.equal(statusWrites.at(-2).key, "caveman");
+  assert.match(statusWrites.at(-2).text, /○.*ON/);
+  assert.match(statusWrites.at(-1).text, /●.*ON/);
+});
+
+test("status bar clears when disabled", async () => {
+  const { events, commands } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_c, t) => t } },
+  });
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("caveman").handler("off", ctx);
+
+  assert.deepEqual(statusWrites.at(-1), { key: "caveman", text: "" });
+});
+
+test("status bar stays silent when ui lacks a theme", async () => {
+  const { events } = createPiHarness();
+  const calls = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [] },
+    ui: { notify() {}, setStatus: (_key, text) => calls.push(text) }, // no theme
+  });
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.deepEqual(calls, []);
+});
+
+test("invalid subcommand notifies warning and does not append", async () => {
+  const { commands, appendedEntries } = createPiHarness();
+  let notified = null;
+  const ctx = createCommandContext({ ui: { notify: (_m, kind) => { notified = kind; } } });
+
+  await commands.get("caveman").handler("banana", ctx);
+
+  assert.equal(notified, "warning");
+  assert.equal(appendedEntries.length, 0);
+});
+
+test("status subcommand reports without changing state", async () => {
+  const { commands, events, appendedEntries } = createPiHarness();
+  let reported = null;
+  const ctx = createCommandContext({ ui: { notify: (m) => { reported = m; } } });
+
+  await events.get("session_start")({ reason: "startup" }, ctx); // starts on
+  await commands.get("caveman").handler("status", ctx);
+
+  assert.match(reported, /ON/);
+  assert.equal(appendedEntries.length, 0);
+});

package/dist/extensions/caveman/test/helpers.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import {
+  getCavemanInstructions,
+  isDeactivationCommand,
+  parseCavemanCommand,
+  resolveSessionActive,
+} from "../index.js";
+
+test("parseCavemanCommand: bare toggles", () => {
+  assert.deepEqual(parseCavemanCommand(""), { type: "toggle" });
+  assert.deepEqual(parseCavemanCommand("   "), { type: "toggle" });
+});
+
+test("parseCavemanCommand: on/off/status", () => {
+  assert.deepEqual(parseCavemanCommand("on"), { type: "set", active: true });
+  assert.deepEqual(parseCavemanCommand("ENABLE"), { type: "set", active: true });
+  assert.deepEqual(parseCavemanCommand("off"), { type: "set", active: false });
+  assert.deepEqual(parseCavemanCommand("disable"), { type: "set", active: false });
+  assert.deepEqual(parseCavemanCommand("status"), { type: "status" });
+});
+
+test("parseCavemanCommand: unknown arg is invalid", () => {
+  assert.deepEqual(parseCavemanCommand("banana"), { type: "invalid", reason: "unknown-subcommand", arg: "banana" });
+});
+
+test("resolveSessionActive: latest persisted entry wins", () => {
+  const entries = [
+    { type: "custom", customType: "caveman-mode", data: { active: false } },
+    { type: "custom", customType: "caveman-mode", data: { active: true } },
+  ];
+  assert.equal(resolveSessionActive(entries, true), true);
+});
+
+test("resolveSessionActive: non-array entries fall back", () => {
+  assert.equal(resolveSessionActive(null, true), true);
+  assert.equal(resolveSessionActive(undefined, false), false);
+  assert.equal(resolveSessionActive({}, true), true);
+  assert.equal(resolveSessionActive("nope"), true); // DEFAULT fallback
+});
+
+test("isDeactivationCommand: only the whole message, case-insensitive, trailing punct ok", () => {
+  assert.equal(isDeactivationCommand("stop caveman"), true);
+  assert.equal(isDeactivationCommand("STOP CAVEMAN!"), true);
+  assert.equal(isDeactivationCommand("normal mode"), true);
+  assert.equal(isDeactivationCommand("Normal Mode."), true);
+  assert.equal(isDeactivationCommand("add a normal mode toggle"), false);
+  assert.equal(isDeactivationCommand("how do I stop caveman re-rendering"), false);
+});
+
+test("getCavemanInstructions reads SKILL.md and strips frontmatter", () => {
+  const instructions = getCavemanInstructions();
+  assert.ok(instructions.startsWith("CAVEMAN MODE ACTIVE"));
+  assert.ok(!instructions.includes("name: caveman")); // frontmatter gone
+  assert.ok(instructions.includes("Respond terse like smart caveman"));
+});
+
+test("getCavemanInstructions matches src/skills/caveman/SKILL.md body", () => {
+  const skillPath = fileURLToPath(new URL("../../../skills/caveman/SKILL.md", import.meta.url));
+  const raw = readFileSync(skillPath, "utf8");
+  const body = raw.replace(/^---[\s\S]*?---\s*/, "");
+
+  assert.ok(getCavemanInstructions().endsWith(body));
+});

package/dist/extensions/copy-turn.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { copyToClipboard } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@selesai/code";
+import { copyToClipboard } from "@selesai/code";
 import { Text } from "@earendil-works/pi-tui";
 
 type AnyMessage = any;

package/dist/extensions/pi-intercom/broker/broker.ts

@@ -1,13 +1,12 @@
 import net from "net";
 import { writeFileSync, unlinkSync, mkdirSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
 import { randomUUID } from "crypto";
 import { writeMessage, createMessageReader } from "./framing.js";
-import { getBrokerSocketPath } from "./paths.js";
+import { getBrokerSocketPath, getIntercomDir } from "./paths.js";
 import type { SessionInfo, Message, Attachment, BrokerMessage } from "../types.js";
 
-const INTERCOM_DIR = join(homedir(), ".pi/agent/intercom");
+const INTERCOM_DIR = getIntercomDir();
 const SOCKET_PATH = getBrokerSocketPath();
 const PID_PATH = join(INTERCOM_DIR, "broker.pid");
 

package/dist/extensions/pi-intercom/broker/paths.ts

@@ -1,5 +1,5 @@
 import { join } from "path";
-import { homedir } from "os";
+import { getAgentDir } from "@selesai/code";
 
 function sanitizePipeSegment(value: string): string {
   return value
@@ -8,13 +8,18 @@ function sanitizePipeSegment(value: string): string {
     .toLowerCase() || "default";
 }
 
+/** selesai config dir (~/.selesai/agent on the selesai fork, ~/.pi/agent upstream). */
+export function getIntercomDir(): string {
+  return join(getAgentDir(), "intercom");
+}
+
 export function getBrokerSocketPath(
   platform: NodeJS.Platform = process.platform,
-  homeDir: string = homedir(),
+  intercomDir: string = getIntercomDir(),
 ): string {
   if (platform === "win32") {
-    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(homeDir)}`;
+    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(intercomDir)}`;
   }
 
-  return join(homeDir, ".pi/agent/intercom/broker.sock");
-}
+  return join(intercomDir, "broker.sock");
+}

package/dist/extensions/pi-intercom/broker/spawn.ts

@@ -2,11 +2,10 @@ import { spawn } from "child_process";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
 import net from "net";
-import { getBrokerSocketPath } from "./paths.js";
+import { getBrokerSocketPath, getIntercomDir } from "./paths.js";
 
-const INTERCOM_DIR = join(homedir(), ".pi/agent/intercom");
+const INTERCOM_DIR = getIntercomDir();
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
 const BROKER_SOCKET = getBrokerSocketPath();
 const BROKER_PID = join(INTERCOM_DIR, "broker.pid");

package/dist/extensions/pi-intercom/config.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
+import { getIntercomDir } from "./broker/paths.js";
 
 export interface IntercomConfig {
   /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
@@ -22,7 +22,7 @@ export interface IntercomConfig {
   replyHint: boolean;
 }
 
-const CONFIG_PATH = join(homedir(), ".pi/agent/intercom/config.json");
+const CONFIG_PATH = join(getIntercomDir(), "config.json");
 
 const defaults: IntercomConfig = {
   brokerCommand: "npx",

package/dist/extensions/pi-intercom/index.ts

@@ -1,7 +1,7 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import { IntercomClient } from "./broker/client.ts";
 import { spawnBrokerIfNeeded } from "./broker/spawn.ts";
 import { SessionListOverlay } from "./ui/session-list.ts";

package/dist/extensions/pi-intercom/package.json

@@ -28,8 +28,8 @@
     ]
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
+    "@selesai/code": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "dependencies": {
     "tsx": "^4.20.0",

package/dist/extensions/pi-intercom/ui/compose.ts

@@ -1,6 +1,6 @@
-import type { Component, TUI } from "@mariozechner/pi-tui";
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import type { KeybindingsManager, Theme } from "@mariozechner/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { KeybindingsManager, Theme } from "@selesai/code";
 import type { IntercomClient } from "../broker/client.js";
 import type { SessionInfo } from "../types.js";
 

package/dist/extensions/pi-intercom/ui/inline-message.ts

@@ -1,6 +1,6 @@
-import type { Component } from "@mariozechner/pi-tui";
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
-import type { Theme } from "@mariozechner/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { Theme } from "@selesai/code";
 import type { SessionInfo, Message } from "../types.js";
 
 export class InlineMessageComponent implements Component {

package/dist/extensions/pi-intercom/ui/session-list.ts

@@ -1,6 +1,6 @@
-import type { Component } from "@mariozechner/pi-tui";
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import type { KeybindingsManager, Theme } from "@mariozechner/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { KeybindingsManager, Theme } from "@selesai/code";
 import type { SessionInfo } from "../types.js";
 
 function middleTruncate(text: string, maxWidth: number): string {

package/dist/extensions/pi-powerline-footer/bash-mode/editor.ts

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
-import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { CustomEditor } from "@selesai/code";
 import { isKeyRelease, matchesKey, visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
-import type { KeybindingsManager } from "@earendil-works/pi-coding-agent/dist/core/keybindings.js";
+import type { KeybindingsManager } from "@selesai/code/dist/core/keybindings.js";
 import type { AutocompleteProvider } from "@earendil-works/pi-tui";
 import { matchesConfiguredShortcut } from "../shortcuts.ts";
 import { getOneOffBashCommandContext } from "./completion.ts";

package/dist/extensions/pi-powerline-footer/bash-mode/history.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+import { getAgentDir } from "@selesai/code";
 
 interface PersistedHistoryEntry {
   command: string;
@@ -13,7 +14,7 @@ function getHomeDir(): string {
 }
 
 function getHistoryDir(): string {
-  return join(getHomeDir(), ".pi", "agent", "powerline-footer", "bash-history");
+  return join(getAgentDir(), "powerline-footer", "bash-history");
 }
 
 function projectKey(cwd: string): string {