chill-agent 1.3.0 → 1.5.0

package/examples/anti-slop-copy.md

@@ -0,0 +1,7 @@
+# Anti-Slop Copywriting Transformation
+
+## AI Slop Copy (Banned)
+> *"Unleash the revolutionary power of our cutting-edge AI debugger! Seamlessly supercharge your development workflow with next-generation intelligence. Trusted by 10,000+ happy developers across the globe! ✨"*
+
+## ChillAgent Clean Copy (Approved)
+> *"ChillRewind is a zero-dependency local proxy running on `node:sqlite` in WAL mode. It prunes stale tool outputs over 1.5KB and halts agent runs when the same tool signature repeats 3 consecutive times."*

package/examples/anti-slop-ui.md

@@ -0,0 +1,14 @@
+# Anti-Slop UI Transformation
+
+## The Generic AI Default (Rejected as Slop)
+- Background: `bg-gradient-to-br from-indigo-500 via-purple-500 to-pink-500`
+- Card: `rounded-3xl shadow-2xl backdrop-blur-xl p-8 bg-white/10`
+- Button: Pill-shaped glowing cyan bubble with rocket emoji `🚀`
+- Heading: *"Unleash the Power of Next-Gen AI"*
+
+## The ChillAgent Standard (Accepted High-Craft)
+- Background: Deep obsidian carbon `#09090B`
+- Card: Monochromatic surface `#111114` with 1px hairline border `#26262E` and 8px radius
+- Numbers: Tabular monospace font `JetBrains Mono`
+- Accent: Single semantic indicator (Emerald `#10B981` for active status)
+- Heading: Direct domain statement: *"Deterministic time-travel debugger for AI agents."*

package/examples/csv-sum.md

@@ -0,0 +1,27 @@
+# CSV Sum
+
+**Task:** "Write Python code that reads sales.csv and sums the 'amount' column."
+
+## Without ChillAgent (20 lines, 1 heavy dependency)
+```python
+import pandas as pd
+
+# Read the CSV file into a DataFrame
+df = pd.read_csv('sales.csv')
+
+# Sum the amount column
+total_amount = df['amount'].sum()
+
+# Print the result
+print(f"Total sales amount: {total_amount}")
+```
+*Bloat:* Forces 35MB `pandas` dependency for a simple column sum.
+
+## With ChillAgent (4 lines, 0 dependencies)
+```python
+import csv
+
+with open('sales.csv') as f:
+    print(sum(float(row['amount']) for row in csv.DictReader(f)))
+```
+*Result:* 0 dependencies, instant execution, standard library only.

package/examples/debounce.md

@@ -0,0 +1,22 @@
+# Debounce Utility
+
+**Task:** "Write a debounce function in TypeScript."
+
+## Without ChillAgent (25 lines + lodash dependency)
+```typescript
+import debounce from 'lodash/debounce';
+export const debouncedSearch = debounce((query: string) => {
+  api.search(query);
+}, 300);
+```
+
+## With ChillAgent (6 lines, standard native timer)
+```typescript
+export function debounce<T extends (...args: any[]) => void>(fn: T, ms = 300) {
+  let timer: ReturnType<typeof setTimeout>;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), ms);
+  };
+}
+```

package/examples/deep-clone.md

@@ -0,0 +1,14 @@
+# Deep Clone
+
+**Task:** "Deep clone a JavaScript object in Node 18+."
+
+## Without ChillAgent
+```javascript
+import cloneDeep from 'lodash/cloneDeep';
+const copy = cloneDeep(source);
+```
+
+## With ChillAgent (1 line native standard library)
+```javascript
+const copy = structuredClone(source);
+```

package/examples/modal-dialog.md

@@ -0,0 +1,19 @@
+# Modal Dialog Component
+
+**Task:** "Create an accessible modal dialog in vanilla HTML/CSS/JS."
+
+## Without ChillAgent (120 lines, custom backdrop, custom focus trap, custom scroll locks)
+Manual z-index soup, forgotten Escape key handlers, broken keyboard traps.
+
+## With ChillAgent (12 lines using native HTML <dialog>)
+```html
+<dialog id="confirmModal" style="border: 1px solid #26262E; border-radius: 8px; background: #111114; color: #F4F4F6; padding: 20px;">
+  <form method="dialog">
+    <p>Confirm irreversible session fork?</p>
+    <button value="cancel">Cancel</button>
+    <button value="confirm" style="background: #818CF8; color: #09090B;">Fork</button>
+  </form>
+</dialog>
+<button onclick="document.getElementById('confirmModal').showModal()">Open</button>
+```
+*Features:* Built-in backdrop, native Escape key closing, native focus trapping, zero external libraries.

package/hooks/chill-activate.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// chill-agent SessionStart activation hook
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const home = os.homedir();
+const flagPath = path.join(home, '.chill-agent-active');
+
+try {
+  fs.writeFileSync(flagPath, JSON.stringify({
+    active: true,
+    mode: 'full',
+    timestamp: Date.now()
+  }), 'utf8');
+
+  // Emit compact active notice
+  process.stdout.write('[chill-agent active: full (ponytail + anti-slop dual core)]\n');
+} catch {}

package/hooks/chill-mode-tracker.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// chill-agent Mode Tracker Hook: detects /chill [lite|full|ultra|off]
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const home = os.homedir();
+const flagPath = path.join(home, '.chill-agent-active');
+
+const prompt = process.argv.slice(2).join(' ');
+const match = prompt.match(/\/chill\s+(lite|full|ultra|off)/i);
+
+if (match) {
+  const newMode = match[1].toLowerCase();
+  try {
+    fs.writeFileSync(flagPath, JSON.stringify({
+      active: newMode !== 'off',
+      mode: newMode,
+      timestamp: Date.now()
+    }), 'utf8');
+    process.stderr.write(`[chill-agent mode switched to: ${newMode}]\n`);
+  } catch {}
+}

package/hooks/chill-statusline.ps1

@@ -0,0 +1,10 @@
+# chill-agent PowerShell statusline indicator
+$flag = Join-Path $HOME ".chill-agent-active"
+if (Test-Path $flag) {
+  try {
+    $data = Get-Content $flag | ConvertFrom-Json
+    if ($data.active) {
+      Write-Host " ◷ chill:$($data.mode) " -ForegroundColor Black -BackgroundColor Cyan -NoNewline
+    }
+  } catch {}
+}

package/hooks/chill-statusline.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# chill-agent bash/zsh statusline indicator
+FLAG="$HOME/.chill-agent-active"
+if [ -f "$FLAG" ]; then
+  MODE=$(grep -o '"mode":"[^"]*' "$FLAG" | cut -d'"' -f4)
+  if [ -n "$MODE" ] && [ "$MODE" != "off" ]; then
+    printf "\033[48;5;81;30m ◷ chill:%s \033[0m" "$MODE"
+  fi
+fi

package/hooks/claude-codex-hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": "node \"./hooks/chill-activate.js\"",
+        "timeout": 15
+      }
+    ]
+  }
+}

package/hooks/copilot-hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": "node \"./hooks/chill-activate.js\"",
+        "timeout": 15
+      }
+    ]
+  }
+}

package/hooks/cursor-hooks.json

@@ -0,0 +1,17 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": "node \"./hooks/chill-activate.js\"",
+        "timeout": 15
+      }
+    ],
+    "beforeSubmitPrompt": [
+      {
+        "command": "node \"./hooks/chill-mode-tracker.js\"",
+        "timeout": 15
+      }
+    ]
+  }
+}

package/hooks/ponytail-activate.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// ponytail — Claude Code SessionStart activation hook (also Codex, Copilot,
+// Grok, CodeBuddy and Cursor sessionStart)
+//
+// Runs on every session start:
+//   1. Writes flag file at $CLAUDE_CONFIG_DIR/.ponytail-active (defaults to ~/.claude; statusline reads this)
+//   2. Emits ponytail ruleset as hidden SessionStart context
+//   3. Detects missing statusline config and emits setup nudge
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { getDefaultMode, getClaudeDir, isShellSafe } = require('./ponytail-config');
+const { getPonytailInstructions } = require('./ponytail-instructions');
+const {
+  clearMode,
+  cursorRuleNotice,
+  cursorRulePath,
+  isCodeBuddy,
+  isCodex,
+  isCopilot,
+  isCursor,
+  readMode,
+  setMode,
+  writeHookOutput,
+} = require('./ponytail-runtime');
+
+const claudeDir = getClaudeDir();
+const settingsPath = path.join(claudeDir, 'settings.json');
+
+function activate(mode) {
+  // "off" mode — skip activation entirely, don't write flag or emit rules
+  if (mode === 'off') {
+    clearMode();
+    process.exit(0);
+  }
+
+  // Cursor with the always-on rule in the workspace: the rule already carries the
+  // ruleset and would contradict any other level, so leave the flag alone and
+  // hand the model a one-line notice instead of a second copy (#817).
+  if (isCursor) {
+    const rule = cursorRulePath();
+    if (rule) {
+      try {
+        writeHookOutput('SessionStart', mode, cursorRuleNotice(rule));
+      } catch (e) {
+        // Silent fail — stdout closed/EPIPE at hook exit must not surface as a hook failure
+      }
+      process.exit(0);
+    }
+  }
+
+  // 1. Write flag file
+  try {
+    setMode(mode);
+  } catch (e) {
+    // Silent fail -- flag is best-effort, don't block the hook
+  }
+
+  // 2. Emit the ponytail ruleset, filtered to the active intensity level.
+  let output = getPonytailInstructions(mode);
+
+  // 2b. Codebase map: what already exists, so "reuse first" costs no search. Fail open: the map
+  // gets 3 s, well inside the 15 s hook limit, so a stalled map never costs the rules (#1079, #1157).
+  // shortcut: a map slower than 3 s is still dropped; a cached per-repo map would lift that if it shows up.
+  if (mode !== 'review' && process.env.PONYTAIL_MAP !== '0') try {
+    const map = execFileSync(process.execPath, [path.join(__dirname, 'ponytail-map.js')], {
+      encoding: 'utf8', timeout: 3000, maxBuffer: 64 * 1024, stdio: ['ignore', 'pipe', 'ignore'],
+    }).trimEnd();
+    if (map) output += '\n\n' + map;
+  } catch (e) { /* no map */ }
+
+  // 3. Detect missing statusline config — nudge Claude to help set it up
+  if (!isCodex && !isCopilot && !isCursor && !isCodeBuddy) try {
+    const isWindows = process.platform === 'win32';
+    let statusCommand = null;
+    if (fs.existsSync(settingsPath)) {
+      // Strip UTF-8 BOM some editors prepend on Windows (breaks JSON.parse)
+      const raw = fs.readFileSync(settingsPath, 'utf8').replace(/^\uFEFF/, '');
+      const settings = JSON.parse(raw);
+      if (settings.statusLine) {
+        statusCommand = String(settings.statusLine.command || '');
+      }
+    }
+
+    // A statusLine already set up before #1032 can still run a script from a
+    // plugin version that has since been deleted. Only absolute paths are checked,
+    // so ~ or $HOME forms are never mistaken for missing files.
+    const ref = statusCommand &&
+      statusCommand.match(/"([^"]*ponytail-statusline\.(?:sh|ps1))"|(\S*ponytail-statusline\.(?:sh|ps1))/);
+    const refPath = ref ? (ref[1] || ref[2]) : null;
+    // isShellSafe keeps quotes, newlines and shell metacharacters from
+    // settings.json out of the model context.
+    // On Windows only drive-letter or UNC paths count: a Git Bash path such as
+    // /c/Users/... is absolute to Node but does not resolve, so it would be
+    // flagged as broken while it works.
+    const checkable = refPath && isShellSafe(refPath) && path.isAbsolute(refPath) &&
+      (!isWindows || /^([A-Za-z]:[\\/]|\\\\)/.test(refPath));
+    const stalePath = checkable && !fs.existsSync(refPath) ? refPath : null;
+
+    // The plugin root is a versioned cache dir (.../ponytail/4.12.0/) that Claude
+    // Code deletes on update, so a statusLine pointing into it goes blank after the
+    // next update (#1032). Point it at a copy in the config dir instead. A statusLine
+    // that already runs ponytail keeps its script type, so its copy stays fresh.
+    const usePs1 = refPath ? refPath.endsWith('.ps1') : isWindows;
+    const scriptName = usePs1 ? 'ponytail-statusline.ps1' : 'ponytail-statusline.sh';
+    const scriptPath = path.join(claudeDir, scriptName);
+
+    // Nudge at most once — the flag file marks that the user has already seen
+    // (and implicitly declined) the statusline setup offer. Repeating it every
+    // session start turns a helpful hint into a nag. A broken path is nudged once
+    // per path: the flag records it.
+    const nudgeFlagPath = path.join(claudeDir, '.ponytail-statusline-nudged');
+    let nudged = null;
+    try { nudged = fs.readFileSync(nudgeFlagPath, 'utf8'); } catch (e) { /* not nudged yet */ }
+    const nudge = stalePath ? nudged !== stalePath : statusCommand === null && nudged === null;
+
+    // Refresh the copy every session so script fixes ship with plugin updates.
+    // Copy to a new temp file, then rename: the rename replaces a symlink at
+    // scriptPath instead of writing through it, and a concurrent session never
+    // runs a half-written script.
+    if (nudge || fs.existsSync(scriptPath)) {
+      const tmpPath = scriptPath + '.' + process.pid + '.tmp';
+      try {
+        fs.copyFileSync(path.join(__dirname, scriptName), tmpPath, fs.constants.COPYFILE_EXCL);
+        fs.chmodSync(tmpPath, 0o644);
+        fs.renameSync(tmpPath, scriptPath);
+      } finally {
+        try { fs.unlinkSync(tmpPath); } catch (e) { /* renamed */ }
+      }
+    }
+
+    if (nudge) {
+      try { fs.writeFileSync(nudgeFlagPath, stalePath || ''); } catch (e) { /* best-effort */ }
+      if (stalePath) {
+        output += "\n\n" +
+          "STATUSLINE BROKEN: The statusLine in " + settingsPath + " runs " + stalePath +
+          ", which no longer exists (the ponytail plugin was updated and its old version removed), " +
+          "so the ponytail badge is blank. Replace that path with " + scriptPath + ", which survives updates, " +
+          "quoting it for your shell. Keep the rest of the command. " +
+          "Proactively offer to fix this for the user on first interaction.";
+      } else if (isShellSafe(scriptPath)) {
+        const command = isWindows
+          ? `powershell -ExecutionPolicy Bypass -File "${scriptPath}"`
+          : `bash "${scriptPath}"`;
+        const statusLineSnippet =
+          '"statusLine": { "type": "command", "command": ' + JSON.stringify(command) + ' }';
+        output += "\n\n" +
+          "STATUSLINE SETUP NEEDED: The ponytail plugin includes a statusline badge showing active mode " +
+          "(e.g. [PONYTAIL], [PONYTAIL:ULTRA]). It is not configured yet. " +
+          "To enable, add this to " + settingsPath + ": " +
+          statusLineSnippet + " " +
+          "Proactively offer to set this up for the user on first interaction.";
+      } else {
+        // ponytail: config dir path has shell metacharacters; don't embed it in a
+        // command snippet; have the agent wire it up by hand instead.
+        output += "\n\n" +
+          "STATUSLINE SETUP NEEDED: The ponytail plugin includes a statusline badge showing active mode. " +
+          "Its path contains characters unsafe to embed in a shell command, so configure it manually: " +
+          "add a statusLine command of type \"command\" that runs " + scriptName +
+          " from " + claudeDir + " to " + settingsPath + ", quoting/escaping the path for your shell. " +
+          "Proactively offer to set this up for the user on first interaction.";
+      }
+    }
+  } catch (e) {
+    // Silent fail — don't block session start over statusline detection
+  }
+
+  try {
+    writeHookOutput('SessionStart', mode, output);
+  } catch (e) {
+    // Silent fail — stdout closed/EPIPE at hook exit must not surface as a hook failure
+  }
+}
+
+// Compaction re-runs SessionStart inside the same conversation, so it keeps the
+// live level (or stays off after "stop ponytail") instead of resetting to the
+// default. Claude Code and Codex pass the trigger as `source` on stdin; reading
+// it there keeps the hook entry, and the trust Codex gave it, unchanged.
+let input = '';
+let done = false;
+
+function finish() {
+  if (done) return;
+  done = true;
+  let source = '';
+  try {
+    // Strip UTF-8 BOM some shells prepend when piping (breaks JSON.parse)
+    source = JSON.parse(input.replace(/^\uFEFF/, '')).source;
+  } catch (e) {
+    // No payload, or an unparseable one: treat it as a fresh session
+  }
+  activate(source === 'compact' ? (readMode() || 'off') : getDefaultMode());
+}
+
+process.stdin.on('data', chunk => { input += chunk; });
+// Never hang the session start (#443, #790): like the mode tracker, recover on a
+// stdin error or after a short ref'd fallback, and start at the default level.
+process.stdin.on('end', () => { finish(); process.exit(0); });
+process.stdin.on('error', () => { finish(); process.exit(0); });
+setTimeout(() => { finish(); process.exit(0); }, 1000);

package/hooks/ponytail-instructions.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+// Shared Ponytail instruction builder for Claude hooks and Pi extension.
+
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_MODE, normalizeMode, normalizePersistedMode } = require('./ponytail-config');
+
+const INDEPENDENT_MODES = new Set(['review']);
+const SKILL_PATH = path.join(__dirname, '..', 'skills', 'ponytail', 'SKILL.md');
+
+function filterSkillBodyForMode(body, mode) {
+  const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
+  const withoutFrontmatter = String(body || '').replace(/^---[\s\S]*?---\s*/, '');
+
+  // Only the intensity table rows and worked examples are mode-specific, and
+  // both are keyed by a mode name (lite/full/ultra). A bullet whose label is
+  // not a mode — e.g. "No unrequested abstractions: ..." — is a normal rule
+  // and must be kept verbatim.
+  return withoutFrontmatter
+    .split(/\r?\n/)
+    .filter((line) => {
+      const tableLabel = line.match(/^\|\s*\*\*(.+?)\*\*\s*\|/);
+      if (tableLabel) {
+        const labelMode = normalizeMode(tableLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      // Require a quoted value: every worked example is `- lite: "..."`. Without
+      // this, an ordinary rule bullet that happens to start with a mode word
+      // (e.g. "- Full: ...") is silently dropped in every other mode — it looks
+      // like a worked example but is really prose meant to survive verbatim.
+      const exampleLabel = line.match(/^-\s*([^:]+):\s*"/);
+      if (exampleLabel) {
+        const labelMode = normalizeMode(exampleLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      return true;
+    })
+    .join('\n');
+}
+
+function getFallbackInstructions(mode) {
+  // Used only when SKILL.md cannot be read: the same rules as AGENTS.md.
+  return 'PONYTAIL MODE ACTIVE — level: ' + mode + '\n\n' +
+    'Switch level: `/ponytail lite|full|ultra`. Off: "stop ponytail" or "normal mode".\n\n' +
+    "You are a lazy senior developer. The best code is the code never written. You solve the whole problem with the least new code. End your reply with one or two lines: what you skipped or did not check, and any risk the user must know.\n" +
+    "\n" +
+    "## Before you write\n" +
+    "\n" +
+    "Read the task and the code it touches. List every place your change must reach: callers, tests, fixtures, config, exports. Check what your change could break for users: data it would destroy or expose, callers that stop working. That is scope. Extra features are not.\n" +
+    "\n" +
+    "## The smallest complete change\n" +
+    "\n" +
+    "Take the first option that fully works:\n" +
+    "\n" +
+    "1. Does it need to exist? Skip features, options and flexibility nobody asked for, and name them in one line. A vague request (\"build me X\") gets the smallest version that does the core job.\n" +
+    "2. Already in this codebase (a helper, component, service, pattern)? Use it the way the surrounding code does.\n" +
+    "3. Standard library or a platform feature? Use it, unless the project has its own. A house component beats a native widget.\n" +
+    "4. An installed dependency? Use it. Never add a dependency for a few lines.\n" +
+    "5. Can it be one line a reader gets at a glance? One line.\n" +
+    "6. Otherwise: the minimum code that works.\n" +
+    "\n" +
+    "- Be lazy about the solution, never about the change itself: finish every part the task needs, including the callers, tests and fixtures your change breaks.\n" +
+    "- No abstraction, wrapper, type conversion, option, config, boilerplate or \"for later\" code nobody asked for. Keep values in the form the platform already gives you. Deletion beats addition. Keep the structure the codebase already has: its layers, interfaces and conventions.\n" +
+    "- The shortest working diff wins, once you know everything it must touch. A one-liner that needs decoding is not short.\n" +
+    "- Comment only the why the code cannot show, in one line.\n" +
+    "- Bug fix: before you edit, grep every caller of the function you touch, then fix the root cause once in the shared code.\n" +
+    "- Code you move or merge keeps its error handling and validation.\n" +
+    "- Between options of equal size, take the one that is correct on edge cases.\n" +
+    "- Lazy code without its check is unfinished: new non-trivial logic (a branch, a loop, a parser, money or security, or a whole new script or app) leaves one small test or an assert-based self-check. Trivial changes need none.\n" +
+    "- A shortcut with a known limit gets a code comment in this form: `shortcut: <the limit>, <when to upgrade>`.\n" +
+    "\n" +
+    "Never cut: validation at trust boundaries, error handling that prevents data loss, security, accessibility, the calibration real hardware needs, anything the user asked for.\n";
+}
+
+function getPonytailInstructions(mode) {
+  const configuredMode = normalizePersistedMode(mode) || DEFAULT_MODE;
+
+  if (INDEPENDENT_MODES.has(configuredMode)) {
+    return 'PONYTAIL MODE ACTIVE — level: ' + configuredMode + '. Behavior defined by /ponytail-' + configuredMode + ' skill.';
+  }
+
+  const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
+
+  try {
+    return 'PONYTAIL MODE ACTIVE — level: ' + effectiveMode + '\n\n' +
+      filterSkillBodyForMode(fs.readFileSync(SKILL_PATH, 'utf8'), effectiveMode);
+  } catch (e) {
+    return getFallbackInstructions(effectiveMode);
+  }
+}
+
+module.exports = {
+  filterSkillBodyForMode,
+  getFallbackInstructions,
+  getPonytailInstructions,
+};