@draig/lexis-two 1.0.0

package/hooks/lexis-two-config.js

@@ -0,0 +1,101 @@
+// lexis-two — shared configuration resolver
+//
+// Resolution order for default mode:
+//   1. LEXIS_TWO_DEFAULT_MODE environment variable
+//   2. Config file defaultMode field:
+//      - $XDG_CONFIG_HOME/lexis-two/config.json (any platform, if set)
+//      - ~/.config/lexis-two/config.json (macOS / Linux fallback)
+//      - %APPDATA%\lexis-two\config.json (Windows fallback)
+//   3. 'full'
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_MODE = 'full';
+const VALID_MODES = ['off', 'lite', 'full', 'ultra', 'review'];
+const RUNTIME_MODES = ['off', 'lite', 'full', 'ultra'];
+
+function normalizeMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return RUNTIME_MODES.includes(normalized) ? normalized : null;
+}
+
+function normalizeConfigMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return VALID_MODES.includes(normalized) ? normalized : null;
+}
+
+function normalizePersistedMode(mode) {
+  return normalizeMode(mode) || normalizeConfigMode(mode);
+}
+
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, 'lexis-two');
+  }
+  if (process.platform === 'win32') {
+    return path.join(
+      process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+      'lexis-two'
+    );
+  }
+  return path.join(os.homedir(), '.config', 'lexis-two');
+}
+
+function getConfigPath() {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+function getClaudeDir() {
+  // lexis-two: CLAUDE_CONFIG_DIR overrides ~/.claude, matching Claude Code.
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function getDefaultMode() {
+  // 1. Environment variable (highest priority)
+  const envMode = process.env.LEXIS_TWO_DEFAULT_MODE;
+  if (envMode && VALID_MODES.includes(envMode.toLowerCase())) {
+    return envMode.toLowerCase();
+  }
+
+  // 2. Config file
+  try {
+    const configPath = getConfigPath();
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (config.defaultMode && VALID_MODES.includes(config.defaultMode.toLowerCase())) {
+      return config.defaultMode.toLowerCase();
+    }
+  } catch (e) {
+    // Config file doesn't exist or is invalid — fall through
+  }
+
+  // 3. Default
+  return DEFAULT_MODE;
+}
+
+function writeDefaultMode(mode) {
+  const normalized = normalizeConfigMode(mode);
+  if (!normalized) return null;
+
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify({ defaultMode: normalized }, null, 2), 'utf8');
+  return normalized;
+}
+
+module.exports = {
+  DEFAULT_MODE,
+  VALID_MODES,
+  RUNTIME_MODES,
+  getDefaultMode,
+  getConfigDir,
+  getConfigPath,
+  getClaudeDir,
+  normalizeMode,
+  normalizeConfigMode,
+  normalizePersistedMode,
+  writeDefaultMode,
+};

package/hooks/lexis-two-instructions.js

@@ -0,0 +1,126 @@
+// lexis-two-instructions.js — shared instruction builder for all Lexis-Two hosts.
+//
+// Forked from ponytail-instructions by DietrichGebert (MIT).
+// Extended for the Lexis ecosystem by @nitdraig.
+//
+// CommonJS so it can be require()'d from ES-module hosts (OpenCode plugin).
+
+"use strict";
+
+const fs = require('fs');
+const path = require('path');
+const { normalizePersistedMode, getDefaultMode } = require('./lexis-two-config');
+
+const LEVELS = {
+  lite: `
+[LEXIS-TWO: lite]
+You are a lazy senior developer. Before writing code, check: is there a native
+platform feature, stdlib method, or already-installed dependency that covers
+this? If yes, use it. Write minimum viable code. Mark shortcuts: // lexis: reason.
+`.trim(),
+
+  full: `
+[LEXIS-TWO: full]
+You are a lazy senior developer. Lazy means efficient, not careless.
+The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+1. Does this need to exist at all? (YAGNI)
+2. Does the standard library already do this? Use it.
+3. Does a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one line? Make it one line.
+6. Only then: write the minimum code that works.
+
+Rules:
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+- Question complex requests: "Do you actually need X, or does Y cover it?"
+- Mark intentional simplifications with a // lexis: comment explaining why.
+- Never rewrite entire files when a targeted edit is sufficient.
+
+Never lazy about: input validation, error handling that prevents data loss,
+security, accessibility, TypeScript types, tests for new behavior.
+`.trim(),
+
+  ultra: `
+[LEXIS-TWO: ultra]
+Delete more than you add. The current codebase has wronged you personally.
+
+Before writing any code:
+1. Can this file be deleted entirely? Delete it.
+2. Can this abstraction be inlined? Inline it.
+3. Can these three functions be one? Make it one.
+4. Can this dependency be replaced with 10 lines? Replace it.
+5. Only then: write the absolute minimum that still passes the tests.
+
+Mark every simplification: // lexis: removed X — Y was sufficient.
+Document ceilings: // lexis: O(n) scan — acceptable under 1k items, revisit at scale.
+
+Never lazy about: input validation, error handling, security, accessibility, types.
+`.trim(),
+};
+
+const INDEPENDENT_MODES = new Set(['review']);
+const SKILL_PATH = path.join(__dirname, '..', 'skills', 'lexis-two', 'SKILL.md');
+
+/**
+ * Filters the skill body for a specific mode.
+ * @param {string} body
+ * @param {string} mode
+ * @returns {string}
+ */
+function filterSkillBodyForMode(body, mode) {
+  const effectiveMode = normalizePersistedMode(mode) || getDefaultMode();
+  const withoutFrontmatter = String(body || '').replace(/^---[\s\S]*?---\s*/, '');
+
+  return withoutFrontmatter
+    .split(/\r?\n/)
+    .filter((line) => {
+      const tableLabel = line.match(/^\|\s*\*\*(.+?)\*\*\s*\|/);
+      if (tableLabel) {
+        const labelMode = normalizePersistedMode(tableLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      const exampleLabel = line.match(/^-\s*([^:]+):\s*/);
+      if (exampleLabel) {
+        const labelMode = normalizePersistedMode(exampleLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      return true;
+    })
+    .join('\n');
+}
+
+/**
+ * Returns the Lexis-Two instruction block for the given mode.
+ * @param {'lite'|'full'|'ultra'} mode
+ * @returns {string}
+ */
+function getLexisInstructions(mode) {
+  const configuredMode = normalizePersistedMode(mode) || getDefaultMode();
+
+  if (INDEPENDENT_MODES.has(configuredMode)) {
+    return 'LEXIS-TWO MODE ACTIVE — level: ' + configuredMode + '. Behavior defined by /lexis-two-' + configuredMode + ' skill.';
+  }
+
+  const effectiveMode = normalizePersistedMode(configuredMode) || getDefaultMode();
+
+  try {
+    return 'LEXIS-TWO MODE ACTIVE — level: ' + effectiveMode + '\n\n' +
+      filterSkillBodyForMode(fs.readFileSync(SKILL_PATH, 'utf8'), effectiveMode);
+  } catch (e) {
+    return LEVELS[effectiveMode] || LEVELS[getDefaultMode()];
+  }
+}
+
+module.exports = {
+  getLexisInstructions,
+  normalizePersistedMode,
+  getDefaultMode,
+  filterSkillBodyForMode,
+};

package/hooks/lexis-two-mode-tracker.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// lexis-two — UserPromptSubmit hook to track which lexis-two mode is active
+// Inspects user input for /lexis-two commands and writes mode to flag file
+
+const { getDefaultMode } = require('./lexis-two-config');
+const { clearMode, setMode, writeHookOutput } = require('./lexis-two-runtime');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    // Strip UTF-8 BOM some shells prepend when piping (breaks JSON.parse)
+    const data = JSON.parse(input.replace(/^\uFEFF/, ''));
+    const prompt = (data.prompt || '').trim().toLowerCase();
+
+    // Match /lexis-two commands
+    if (/^[/@$]lexis-two/.test(prompt)) {
+      const parts = prompt.split(/\s+/);
+      const cmd = parts[0].replace(/^[@$]/, '/');
+      const arg = parts[1] || '';
+
+      let mode = null;
+
+      if (cmd === '/lexis-two-review' || cmd === '/lexis-two:lexis-two-review') {
+        mode = 'review';
+      } else if (cmd === '/lexis-two' || cmd === '/lexis-two:lexis-two') {
+        if (arg === 'lite') mode = 'lite';
+        else if (arg === 'full') mode = 'full';
+        else if (arg === 'ultra') mode = 'ultra';
+        else if (arg === 'off') mode = 'off';
+        else mode = getDefaultMode();
+      }
+
+      if (mode && mode !== 'off') {
+        setMode(mode);
+        writeHookOutput(
+          'UserPromptSubmit',
+          mode,
+          'LEXIS-TWO MODE CHANGED — level: ' + mode,
+        );
+      } else if (mode === 'off') {
+        clearMode();
+        writeHookOutput('UserPromptSubmit', 'off', 'LEXIS-TWO MODE OFF');
+      }
+    }
+
+    // Detect deactivation
+    if (/\b(stop lexis|normal mode)\b/i.test(prompt)) {
+      clearMode();
+      writeHookOutput('UserPromptSubmit', 'off', 'LEXIS-TWO MODE OFF');
+    }
+  } catch (e) {
+    // Silent fail
+  }
+});

package/hooks/lexis-two-runtime.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const path = require('path');
+const { getClaudeDir } = require('./lexis-two-config');
+
+const STATE_FILE = '.lexis-two-active';
+const isCopilot = Boolean(process.env.COPILOT_PLUGIN_DATA);
+const isCodex = !isCopilot && Boolean(process.env.PLUGIN_DATA);
+
+let stateDir = getClaudeDir();
+if (isCodex) stateDir = process.env.PLUGIN_DATA;
+if (isCopilot) stateDir = process.env.COPILOT_PLUGIN_DATA;
+
+const statePath = path.join(stateDir, STATE_FILE);
+
+function setMode(mode) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, mode);
+}
+
+function clearMode() {
+  try { fs.unlinkSync(statePath); } catch (e) {}
+}
+
+function writeHookOutput(event, mode, context = '') {
+  if (isCopilot) {
+    process.stdout.write(JSON.stringify(
+      event === 'SessionStart' && context ? { additionalContext: context } : {}));
+    return;
+  }
+  if (isCodex) {
+    const output = { systemMessage: `LEXIS-TWO:${mode.toUpperCase()}` };
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context,
+      };
+    }
+    process.stdout.write(JSON.stringify(output));
+    return;
+  }
+  process.stdout.write(context);
+}
+
+module.exports = {
+  clearMode,
+  isCodex,
+  isCopilot,
+  setMode,
+  writeHookOutput,
+};

package/hooks/lexis-two-statusline.ps1

@@ -0,0 +1,19 @@
+$Flag = Join-Path $HOME ".claude/.lexis-two-active"
+if (-not (Test-Path $Flag)) {
+    exit 0
+}
+
+$Mode = ""
+try {
+    $Mode = (Get-Content $Flag -ErrorAction Stop | Select-Object -First 1).Trim()
+} catch {
+    exit 0
+}
+
+$Esc = [char]27
+if ([string]::IsNullOrEmpty($Mode) -or $Mode -eq "full") {
+    [Console]::Write("${Esc}[38;5;108m[LEXIS-TWO]${Esc}[0m")
+} else {
+    $Suffix = $Mode.ToUpperInvariant()
+    [Console]::Write("${Esc}[38;5;108m[LEXIS-TWO:$Suffix]${Esc}[0m")
+}

package/hooks/lexis-two-statusline.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+flag="$HOME/.claude/.lexis-two-active"
+[ -f "$flag" ] || exit 0
+
+mode=$(head -n1 "$flag" | tr -d '[:space:]')
+
+if [ -z "$mode" ] || [ "$mode" = "full" ]; then
+    printf '\033[38;5;108m[LEXIS-TWO]\033[0m'
+else
+    printf '\033[38;5;108m[LEXIS-TWO:%s]\033[0m' "$(printf '%s' "$mode" | tr '[:lower:]' '[:upper:]')"
+fi

package/opencode.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["./.opencode/plugins/lexis-two.mjs"]
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@draig/lexis-two",
+  "version": "1.0.0",
+  "description": "The simple way to obtain the best code. Portable rules, skills, and slash commands for AI agents with lowest tokens usage.",
+  "main": "./.opencode/plugins/lexis-two.mjs",
+  "exports": {
+    "./server": "./.opencode/plugins/lexis-two.mjs"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "skills",
+    "lexis-two"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "test": "node --test tests/*.test.js && npm test --prefix pi-extension",
+    "benchmark:opencode-go": "node benchmarks/benchmark-opencode-go.js --repeat 3 --write-md",
+    "benchmark:report": "node benchmarks/render-opencode-go-report.js",
+    "site:dev": "npm run dev --prefix site",
+    "site:build": "npm run build --prefix site"
+  },
+  "pi": {
+    "extensions": [
+      "./pi-extension/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  }
+}

package/pi-extension/index.js

@@ -0,0 +1,161 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const {
+  DEFAULT_MODE,
+  getDefaultMode,
+  normalizeMode,
+  normalizeConfigMode,
+  normalizePersistedMode,
+  writeDefaultMode,
+} = require("../hooks/lexis-two-config.js");
+const { getLexisInstructions, filterSkillBodyForMode } = require("../hooks/lexis-two-instructions.js");
+
+export { filterSkillBodyForMode };
+export const readDefaultMode = getDefaultMode;
+
+export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(fallbackMode) || DEFAULT_MODE;
+  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 !== "lexis-two-mode") continue;
+
+    const mode = normalizePersistedMode(entry?.data?.mode);
+    if (mode) return mode;
+  }
+
+  return fallback;
+}
+
+export function parseLexisCommand(text, defaultMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(defaultMode) || DEFAULT_MODE;
+  const normalizedText = String(text || "").trim().toLowerCase();
+
+  if (!normalizedText) {
+    return { type: "set-mode", mode: fallback === "off" ? "full" : fallback };
+  }
+
+  const [primary, secondary] = normalizedText.split(/\s+/);
+
+  if (primary === "status") return { type: "status" };
+
+  if (primary === "default") {
+    const mode = normalizeConfigMode(secondary);
+    return mode ? { type: "set-default", mode } : { type: "invalid", reason: "invalid-default-mode" };
+  }
+
+  const mode = normalizeMode(primary);
+  return mode ? { type: "set-mode", mode } : { type: "invalid", reason: "invalid-mode", mode: primary };
+}
+
+export { writeDefaultMode };
+
+export default function lexisExtension(pi) {
+  let currentMode = DEFAULT_MODE;
+  let configuredDefaultMode = getDefaultMode();
+
+  const setMode = (mode, ctx) => {
+    const normalized = normalizePersistedMode(mode);
+    if (!normalized) return;
+
+    currentMode = normalized;
+    pi.appendEntry("lexis-two-mode", { mode: normalized });
+    ctx?.ui?.notify?.(`Lexis-Two mode set to ${normalized}.`, "info");
+  };
+
+  const sendAlias = (skillName, args, ctx) => {
+    const normalized = String(args || "").trim();
+    const message = normalized ? `${skillName} ${normalized}` : skillName;
+
+    if (ctx?.isIdle?.() === false) {
+      pi.sendUserMessage(message, { deliverAs: "followUp" });
+      ctx?.ui?.notify?.(`${skillName} queued as follow-up.`, "info");
+      return;
+    }
+
+    pi.sendUserMessage(message);
+  };
+
+  pi.registerCommand("lexis-two", {
+    description: "Set or report Lexis-Two mode",
+    handler: async (args, ctx) => {
+      const parsed = parseLexisCommand(args, configuredDefaultMode);
+
+      if (parsed.type === "status") {
+        ctx?.ui?.notify?.(`Lexis-Two: current ${currentMode} • default ${configuredDefaultMode}`, "info");
+        return;
+      }
+
+      if (parsed.type === "set-default") {
+        const written = writeDefaultMode(parsed.mode);
+        if (written) {
+          configuredDefaultMode = getDefaultMode();
+          const message = configuredDefaultMode === written
+            ? `Default Lexis-Two mode set to ${written}.`
+            : `Saved default ${written}, but env override keeps default at ${configuredDefaultMode}.`;
+          ctx?.ui?.notify?.(message, "info");
+        }
+        return;
+      }
+
+      if (parsed.type === "set-mode") {
+        setMode(parsed.mode, ctx);
+        return;
+      }
+
+      ctx?.ui?.notify?.("Unknown or unsupported /lexis-two mode.", "warning");
+    },
+  });
+
+  pi.registerCommand("lexis-two-review", {
+    description: "Run /skill:lexis-two-review",
+    handler: (_args, ctx) => sendAlias("/skill:lexis-two-review", "", ctx),
+  });
+
+  pi.registerCommand("lexis-two-audit", {
+    description: "Run /skill:lexis-two-audit",
+    handler: (_args, ctx) => sendAlias("/skill:lexis-two-audit", "", ctx),
+  });
+
+  pi.registerCommand("lexis-two-debt", {
+    description: "Run /skill:lexis-two-debt",
+    handler: (_args, ctx) => sendAlias("/skill:lexis-two-debt", "", ctx),
+  });
+
+  pi.registerCommand("lexis-two-plan", {
+    description: "Run /skill:lexis-two-plan",
+    handler: (_args, ctx) => sendAlias("/skill:lexis-two-plan", "", ctx),
+  });
+
+  pi.registerCommand("lexis-two-security", {
+    description: "Run /skill:lexis-two-security",
+    handler: (_args, ctx) => sendAlias("/skill:lexis-two-security", "", ctx),
+  });
+
+  pi.registerCommand("lexis-two-help", {
+    description: "Run /skill:lexis-two-help",
+    handler: (_args, ctx) => sendAlias("/skill:lexis-two-help", "", ctx),
+  });
+
+  pi.on("input", async (event) => {
+    if (event?.source === "extension") return;
+
+    const text = String(event?.text || "");
+    if (currentMode !== "off" && /\b(stop lexis|normal mode)\b/i.test(text)) {
+      setMode("off");
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+    configuredDefaultMode = getDefaultMode();
+    currentMode = resolveSessionMode(entries, configuredDefaultMode);
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    if (!currentMode || currentMode === "off") return;
+    return { systemPrompt: `${event.systemPrompt}\n\n${getLexisInstructions(currentMode)}` };
+  });
+}

package/pi-extension/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "lexis-two-pi-extension-dev",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test ./test/*.test.js"
+  }
+}

package/pi-extension/test/extension.test.js

@@ -0,0 +1,89 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import lexisExtension from "../index.js";
+
+class MockPi {
+  constructor() {
+    this.commands = {};
+    this.listeners = {};
+    this.entries = [];
+    this.userMessages = [];
+  }
+
+  registerCommand(name, config) {
+    this.commands[name] = config;
+  }
+
+  on(event, handler) {
+    this.listeners[event] = handler;
+  }
+
+  appendEntry(type, data) {
+    this.entries.push({ type, data });
+  }
+
+  sendUserMessage(text, options) {
+    this.userMessages.push({ text, options });
+  }
+}
+
+test("lexisExtension registers commands and listeners", () => {
+  const pi = new MockPi();
+  lexisExtension(pi);
+
+  assert.ok(pi.commands["lexis-two"]);
+  assert.ok(pi.commands["lexis-two-review"]);
+  assert.ok(pi.commands["lexis-two-audit"]);
+  assert.ok(pi.commands["lexis-two-debt"]);
+  assert.ok(pi.commands["lexis-two-plan"]);
+  assert.ok(pi.commands["lexis-two-security"]);
+  assert.ok(pi.commands["lexis-two-help"]);
+
+  assert.ok(pi.listeners["input"]);
+  assert.ok(pi.listeners["session_start"]);
+  assert.ok(pi.listeners["before_agent_start"]);
+});
+
+test("lexisExtension command handlers trigger correctly", async () => {
+  const pi = new MockPi();
+  lexisExtension(pi);
+
+  let notified = null;
+  const ctx = {
+    ui: {
+      notify: (msg, type) => {
+        notified = { msg, type };
+      },
+    },
+  };
+
+  await pi.commands["lexis-two"].handler("lite", ctx);
+  assert.equal(pi.entries[0].type, "lexis-two-mode");
+  assert.equal(pi.entries[0].data.mode, "lite");
+  assert.equal(notified.msg, "Lexis-Two mode set to lite.");
+
+  pi.commands["lexis-two-review"].handler("", ctx);
+  assert.equal(pi.userMessages[0].text, "/skill:lexis-two-review");
+});
+
+test("lexisExtension input listener detects deactivation", async () => {
+  const pi = new MockPi();
+  lexisExtension(pi);
+
+  let notified = null;
+  const ctx = {
+    ui: {
+      notify: (msg, type) => {
+        notified = { msg, type };
+      },
+    },
+  };
+
+  // Set mode to full first
+  await pi.commands["lexis-two"].handler("full", ctx);
+  assert.equal(pi.entries[0].data.mode, "full");
+
+  // Send input "stop lexis"
+  await pi.listeners["input"]({ text: "Please stop lexis now" });
+  assert.equal(pi.entries[1].data.mode, "off");
+});