chill-agent 1.4.0 → 1.6.0

package/scripts/skill-index.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Builds the per-skill catalogue that GUIDE.md carries, from the skills themselves.
+ *
+ *   node scripts/skill-index.mjs
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..')
+
+export const START = '<!-- antislop:skills:start -->'
+export const END = '<!-- antislop:skills:end -->'
+
+// One plain-English line per skill, and the order the guide lists them in. The frontmatter
+// description is written for an agent to match on, not for a person to read.
+const NOTES = {
+  antislop:
+    'The core, and it is always loaded. All 40 rules and the Delivery Gate live here, so every task gets them whether or not you pick anything else. The five skills below add depth to it.',
+  'antislop-ui':
+    'Load it when the AI builds or restyles anything you can see: color, layout, cards, buttons, motion. Sized media and load priority are built in.',
+  'antislop-copywriting':
+    'Load it when the AI writes or edits text: headlines, buttons, emails, or a page of prose. It removes the excited, empty voice and the made-up numbers.',
+  'antislop-human':
+    'Load it when real people have to use the result. Readable colors, keyboard use, visible focus, button states, the pointer cursor and other interaction affordances, WCAG 2.2 references, and the contrast checker.',
+  'antislop-layoutmobile':
+    'Load it when the same page has to work on a phone and on a desktop. Reflow, breakpoints, overflow, tap targets, mobile navigation.',
+  'antislop-code':
+    'Load it when the AI writes or reviews code comments. It removes the ones an AI adds out of habit and keeps the ones that carry information.',
+}
+
+// A pattern entry opens with one of these labels; every other heading under a skill is prose.
+const ENTRY = /^\s*-\s*\*\*(?:Tell|The pattern):\*\*/m
+// A fenced example can hold a '### ' line of its own, so read with the fences taken out.
+const unfenced = (text) => text.replace(/^[ \t]*(?:```|~~~)[\s\S]*?^[ \t]*(?:```|~~~)[ \t]*$/gm, '')
+
+const blocksOf = (body, level) => body.split(new RegExp(`^${level} `, 'm')).slice(1)
+
+const HEAD = '| What it covers | The patterns it names |\n|----------------|-----------------------|'
+
+export function buildIndex() {
+  const names = fs
+    .readdirSync(path.join(root, 'skills'), { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+
+  const unlisted = names.filter((n) => !NOTES[n])
+  if (unlisted.length) throw new Error(`scripts/skill-index.mjs has no intro for: ${unlisted.join(', ')}`)
+  const gone = Object.keys(NOTES).filter((n) => !names.includes(n))
+  if (gone.length) throw new Error(`scripts/skill-index.mjs describes a skill that is gone: ${gone.join(', ')}`)
+
+  const out = []
+  for (const name of Object.keys(NOTES)) {
+    const raw = fs.readFileSync(path.join(root, 'skills', name, 'SKILL.md'), 'utf8').replace(/\r\n/g, '\n')
+    const rows = []
+    for (const section of blocksOf(unfenced(raw), '##')) {
+      const title = section.split('\n')[0].trim()
+      const found = blocksOf(section, '###')
+        .filter((block) => ENTRY.test(block))
+        .map((block) => block.split('\n')[0].trim())
+      if (found.length) rows.push(`| ${title} | ${found.join(', ')} |`)
+    }
+    out.push(`### ${name}`, '', NOTES[name], '')
+    if (rows.length) out.push(HEAD, ...rows, '')
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n'
+}
+
+// Run directly to write it into the guide; imported by check-repo to prove the guide is current.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const file = path.join(root, 'GUIDE.md')
+  const guide = fs.readFileSync(file, 'utf8')
+  const from = guide.indexOf(START)
+  const to = guide.indexOf(END)
+  if (from === -1 || to === -1) throw new Error(`GUIDE.md has no ${START} ... ${END} pair`)
+  const eol = guide.includes('\r\n') ? '\r\n' : '\n'
+  const block = buildIndex().replace(/\n/g, eol)
+  fs.writeFileSync(file, guide.slice(0, from + START.length) + eol + block + guide.slice(to))
+  console.log('Regenerated the skill catalogue in GUIDE.md')
+}

package/scripts/sync-ponytail.mjs

@@ -0,0 +1,65 @@
+// scripts/sync-ponytail.mjs
+import fs from 'node:fs';
+import path from 'node:path';
+
+const filesToFetch = [
+  '__init__.py',
+  '.agents/rules/ponytail.md',
+  '.claude-plugin/marketplace.json',
+  '.clinerules/ponytail.md',
+  '.github/FUNDING.yml',
+  '.github/copilot-instructions.md',
+  '.github/plugin/marketplace.json',
+  '.github/plugin/plugin.json',
+  '.github/workflows/publish.yml',
+  '.github/workflows/test.yml',
+  '.grok-plugin/marketplace.json',
+  '.kiro/steering/ponytail.md',
+  '.qoder/rules/ponytail.md',
+  '.windsurf/rules/ponytail.md',
+  '.cursor/rules/ponytail.mdc',
+  '.opencode/command/ponytail-audit.md',
+  '.opencode/command/ponytail-debt.md',
+  '.opencode/command/ponytail-gain.md',
+  '.opencode/command/ponytail-help.md',
+  '.opencode/command/ponytail-review.md',
+  '.opencode/command/ponytail.md',
+  '.opencode/plugins/index.js',
+  '.opencode/plugins/ponytail-frontmatter.cjs',
+  '.opencode/plugins/ponytail.mjs',
+  'hooks/ponytail-activate.js',
+  'hooks/ponytail-mode-tracker.js',
+  'hooks/ponytail-instructions.js',
+  'hooks/ponytail-runtime.js',
+  'hooks/ponytail-statusline.ps1',
+  'hooks/ponytail-statusline.sh',
+  'pi-extension/index.js',
+  'pi-extension/package.json',
+  'scripts/check-rule-copies.js',
+  'scripts/check-versions.js',
+  'scripts/cursor-hooks.js',
+  'scripts/uninstall.js'
+];
+
+async function run() {
+  console.log('Fetching and syncing full ponytail files...');
+  for (const rel of filesToFetch) {
+    try {
+      const url = `https://raw.githubusercontent.com/DietrichGebert/ponytail/main/${rel}`;
+      const res = await fetch(url);
+      if (res.ok) {
+        const text = await res.text();
+        const dir = path.dirname(rel);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(rel, text, 'utf8');
+        console.log(`✓ Synced: ${rel} (${text.length} B)`);
+      } else {
+        console.warn(`✗ Not found (${res.status}): ${rel}`);
+      }
+    } catch (err) {
+      console.error(`Error on ${rel}:`, err.message);
+    }
+  }
+}
+
+run();

package/scripts/uninstall.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// ponytail — removes state ponytail wrote outside the plugin's own files:
+// the mode flag, the config file, the statusline script copy, the
+// statusLine entry it added to settings.json, and its entries in
+// ~/.cursor/hooks.json. Plugin files themselves are removed by each host's
+// own uninstall command (see README); this only cleans up what those
+// commands can't see.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { getConfigPath, getClaudeDir, getQoderDir } = require('../hooks/ponytail-config');
+const cursorHooks = require('./cursor-hooks');
+
+const STATUSLINE_SCRIPT = /(?:^|[\s"'\\/])ponytail-statusline\.(?:sh|ps1)(?=$|[\s"'])/;
+
+function removeIfExists(filePath, label) {
+  try {
+    fs.unlinkSync(filePath);
+    console.log(`Removed ${label}: ${filePath}`);
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+}
+
+removeIfExists(path.join(getClaudeDir(), '.ponytail-active'), 'mode flag');
+removeIfExists(path.join(getClaudeDir(), '.ponytail-statusline-nudged'), 'statusline nudge flag');
+removeIfExists(path.join(os.homedir(), '.cursor', '.ponytail-active'), 'Cursor mode flag');
+removeIfExists(path.join(getQoderDir(), '.ponytail-active'), 'Qoder mode flag');
+for (const dir of [path.join(getClaudeDir(), 'ponytail-modes'), path.join(os.homedir(), '.cursor', 'ponytail-modes'), path.join(process.env.CODEBUDDY_CONFIG_DIR || path.join(os.homedir(), '.codebuddy'), 'ponytail-modes')]) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true });
+    console.log(`Removed per-project mode flags: ${dir}`);
+  }
+}
+removeIfExists(path.join(process.env.CODEBUDDY_CONFIG_DIR || path.join(os.homedir(), '.codebuddy'), '.ponytail-active'), 'CodeBuddy mode flag');
+removeIfExists(path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'opencode', '.ponytail-active'), 'OpenCode mode flag');
+removeIfExists(getConfigPath(), 'config file');
+// Statusline script copies the activate hook keeps in the config dir (#1032).
+for (const name of ['ponytail-statusline.sh', 'ponytail-statusline.ps1']) {
+  removeIfExists(path.join(getClaudeDir(), name), 'statusline script');
+}
+
+// Cursor hooks (#817): drop only ponytail's entries from ~/.cursor/hooks.json,
+// keep every other hook the user configured there.
+try {
+  const hooksFile = cursorHooks.uninstall('user');
+  if (hooksFile) console.log(`Removed ponytail hooks from ${hooksFile}`);
+} catch (e) {
+  if (e instanceof SyntaxError) {
+    // ponytail: malformed hooks.json — can't safely edit it; leave intact, warn
+    console.warn(`~/.cursor/hooks.json is malformed — could not remove the ponytail hook entries. Remove them manually from: ${cursorHooks.hooksPath('user')} (${e.message})`);
+  } else {
+    throw e;
+  }
+}
+
+const settingsPath = path.join(getClaudeDir(), 'settings.json');
+try {
+  const raw = fs.readFileSync(settingsPath, 'utf8').replace(/^\uFEFF/, '');
+  const settings = JSON.parse(raw);
+  const cmd = settings.statusLine && settings.statusLine.command;
+  // Only remove the parts ponytail owns. If the user combined statuslines
+  // (e.g. caveman && ponytail), keep the other plugin's command intact.
+  // ponytail: splits on && / ; to detect other segments — good enough; a user
+  // piping statuslines together is on their own.
+  if (typeof cmd === 'string' && STATUSLINE_SCRIPT.test(cmd)) {
+    const parts = cmd
+      .split(/&&|;/)
+      .map((s) => s.trim())
+      .filter(Boolean);
+    const others = parts.filter((s) => !STATUSLINE_SCRIPT.test(s));
+    if (others.length === 0) {
+      delete settings.statusLine;
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+      console.log(`Removed ponytail statusLine entry from ${settingsPath}`);
+    } else {
+      settings.statusLine.command = others.join(' && ');
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+      console.log(`Removed ponytail statusLine segment from ${settingsPath}`);
+    }
+  }
+} catch (e) {
+  if (e.code === 'ENOENT') {
+    // no settings.json — nothing to clean
+  } else if (e instanceof SyntaxError) {
+    // ponytail: malformed settings.json — can't safely edit it; leave intact, warn
+    console.warn(`settings.json is malformed — could not remove the ponytail statusLine entry. Remove it manually from: ${settingsPath} (${e.message})`);
+  } else {
+    throw e;
+  }
+}