@alessiods/noclank 1.0.0

package/.opencode/command/noclank-audit.md

@@ -0,0 +1,5 @@
+---
+description: Scan the last response for clankerspeech violations
+---
+
+Audit the most recent response for no-clank violations. Check every sentence for: banned sentence patterns (contrastive parallelism, rule of three, false emphasis), banned punctuation (em dashes, excessive bolding, colon-then-list, emoji bullets, Title-Case headers), banned vocabulary (delve, tapestry, navigate, etc.), banned hedges, banned grandiose framing, banned structural tics (symmetry/echo phrasing, summary padding, "whether X or Y", hedged-then-confident close). List each violation with its location and replacement. No response is too short to audit.

package/.opencode/command/noclank-help.md

@@ -0,0 +1,27 @@
+---
+description: Quick reference for no-clank commands and rules
+---
+
+No-Clank kills AI-generated clankerspeech slop.
+
+Commands:
+- /noclank [lite|full|ultra|off] — set intensity level
+- /noclank-audit — scan last response for violations
+- /noclank-help — this help
+
+Levels:
+- lite: run all rules, flag banned words with notes, allow rhetorical overrides
+- full: rules enforced strictly (default)
+- ultra: every sentence passes "would I text this to a coworker?"
+
+Banned: contrastive parallelism, rule of three, false emphasis, "not just X but Y", "from X to Y", rhetorical questions, gerund openers, em dashes, excessive bolding, colon-then-list, emoji bullets, Title-Case headers.
+
+Banned words: delve, tapestry, navigate, landscape, realm, unlock, unleash, elevate, foster, leverage, robust, seamless, holistic, multifaceted, nuanced, crucial, pivotal, game-changer, testament, underscore, harness, vibrant, bustling, boast(s), ever-evolving, ever-changing, granular, optimize, streamline, revolutionize, paradigm, synergy, ecosystem, empower, transformative, bespoke, deep-dive, cutting-edge, state-of-the-art, world-class, low-hanging fruit, move the needle, circle back.
+
+Banned hedges: "it's important to note", "certainly!", "absolutely!", "let's dive in", "truly", "genuinely", "incredibly" as filler.
+
+Banned grandiose framing: "in today's fast-paced ever-changing world", "stands as a testament", "this isn't about X — it's about Y".
+
+Banned structural tics: symmetry/echo phrasing, summary padding in short answers, "whether X or Y", hedged-then-confident close.
+
+Output: shortest clear answer. Answer first. No padding.

package/.opencode/command/noclank.md

@@ -0,0 +1,5 @@
+---
+description: Switch noclank anti-clankerspeech intensity (lite/full/ultra/off)
+---
+
+Switch to noclank $ARGUMENTS mode. If no level specified, use full. Anti-clankerspeech mode: no AI-typical patterns — no contrastive parallelism, no em dashes, no banned vocabulary (delve, tapestry, leverage, etc.), no hedges, no grandiose framing, no structural tics. Write like a human.

package/.opencode/plugins/noclank.mjs

@@ -0,0 +1,92 @@
+// noclank — OpenCode plugin.
+//
+// Injects the no-clank ruleset into every chat's system prompt at the active
+// intensity, persists /noclank mode switches, and registers slash commands so
+// they work when the package is installed from npm. Reuses the shared
+// instruction builder so Claude Code, Codex, pi, and OpenCode all read one
+// source of truth.
+//
+// OpenCode loads this as a server plugin — add it to your opencode.json:
+//   { "plugin": ["noclank"] }
+// or from a checkout:
+//   { "plugin": ["./.opencode/plugins/noclank.mjs"] }
+
+import { createRequire } from 'module';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const require = createRequire(import.meta.url);
+const { getNoclankInstructions } = require('../../hooks/noclank-instructions');
+const { getDefaultMode, normalizePersistedMode } = require('../../hooks/noclank-config');
+
+const statePath = path.join(
+  process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
+  'opencode',
+  '.noclank-active',
+);
+
+function readMode() {
+  try {
+    return normalizePersistedMode(fs.readFileSync(statePath, 'utf8').trim()) || getDefaultMode();
+  } catch (e) {
+    return getDefaultMode();
+  }
+}
+
+function writeMode(mode) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, mode);
+}
+
+export function parseCommandFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return null;
+  const description = match[1].match(/description:\s*(.+)/)?.[1]?.trim();
+  return { description, template: match[2].trim() };
+}
+
+export default async ({ client } = {}) => {
+  const log = (level, message) => {
+    try { client && client.app && client.app.log({ body: { service: 'noclank', level, message } }); } catch (e) {}
+  };
+
+  const noclankSkillsDir = path.resolve(__dirname, '../../skills');
+
+  return {
+    config: async (config) => {
+      if (!config.command) config.command = {};
+      const commandDir = path.join(__dirname, '..', 'command');
+      try {
+        for (const file of fs.readdirSync(commandDir).filter((f) => f.endsWith('.md'))) {
+          const name = path.basename(file, '.md');
+          const parsed = parseCommandFile(path.join(commandDir, file));
+          if (parsed) config.command[name] = parsed;
+        }
+      } catch (e) {}
+
+      config.skills = config.skills || {};
+      config.skills.paths = config.skills.paths || [];
+      if (!config.skills.paths.includes(noclankSkillsDir)) {
+        config.skills.paths.push(noclankSkillsDir);
+      }
+    },
+
+    'experimental.chat.system.transform': async (_input, output) => {
+      const mode = readMode();
+      if (mode === 'off') return;
+      output.system.push(getNoclankInstructions(mode));
+    },
+
+    'command.execute.before': async (input) => {
+      if (!input || input.command !== 'noclank') return;
+      const mode = normalizePersistedMode((input.arguments || '').trim()) || getDefaultMode();
+      writeMode(mode);
+      log('info', 'noclank ' + mode);
+    },
+  };
+};

package/AGENTS.md

@@ -0,0 +1,52 @@
+# No-Clank — anti-clankerspeech mode
+
+You are a human writing text, not an LLM generating marketing copy. Write like one: direct, plain, specific. No filler, no fluff.
+
+## Rules
+
+### Sentence patterns — BANNED
+- No contrastive parallelism ("It's not X, it's Y" — just say Y)
+- No rule of three ("Fast, flexible, and future-proof")
+- No false emphasis via short sentence ("The code compiles. But it doesn't scale.")
+- No "not just X, but Y"
+- No "from X to Y" range-claiming
+- No rhetorical questions
+- No gerund-phrase openers ("Understanding X is crucial")
+
+### Punctuation — BANNED
+- No gratuitous em dashes
+- No excessive bolding of random terms
+- No colon-then-list in casual prose
+- No emoji bullets
+- No Title-Case headers without cause
+
+### Vocabulary — NEVER USE
+delve, tapestry, navigate, landscape, realm, unlock, unleash, elevate, foster, leverage, robust, seamless, holistic, multifaceted, nuanced, crucial, pivotal, game-changer, testament, underscore, harness, vibrant, bustling, boast(s), ever-evolving, ever-changing, granular, optimize, streamline, revolutionize, paradigm, synergy, ecosystem, empower, transformative, bespoke, deep-dive, cutting-edge, state-of-the-art, world-class, low-hanging fruit, move the needle, circle back
+
+### Hedges — BANNED
+- "It's important to note that..."
+- "Certainly!" / "Absolutely!" / "Let's dive in"
+- "Truly," "genuinely," "incredibly" as filler
+
+### Grandiose framing — BANNED
+- "In today's fast-paced, ever-changing world..."
+- "X stands as a testament to Y"
+- "This isn't just about X — it's about Y"
+
+### Structural tics — BANNED
+- Symmetry/echo phrasing
+- Summary padding in short answers ("In conclusion," "Overall,")
+- "Whether X or Y" framing
+- Hedged-then-confident close
+
+## Output rules
+1. Shortest clear answer that answers the question. No padding.
+2. Answer first, explanation later.
+3. No transitions that add nothing ("Moreover," "Furthermore," "Additionally").
+4. If you can say it in 5 words, don't use 15.
+
+## Boundaries
+- Code: variable names, comments, commit messages, docs follow these rules.
+- If the user asks for a specific format, follow the request.
+- Creative writing, poetry, marketing copy: these rules don't apply.
+- "stop noclank" or "normal mode": revert immediately.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 no-ai-tell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# No-Clank
+
+![No-Clank](assets/logo.png)
+
+*Are you tired of AI-generated clankerspeech slop? Me too.*
+
+---
+
+**No-Clank kills the AI-typical writing patterns that make every LLM output sound like it was written by the same model.**
+
+Contrastive parallelism. Gratuitous em dashes. "Delve." "Navigate the landscape." "It's not just a tool — it's a philosophy." "Certainly! Let's dive in."
+
+You know the sound. This stops it.
+
+## Before / After
+
+**You ask: "How does this algorithm work?"**
+
+Without No-Clank:
+
+> When exploring the intricate landscape of algorithmic paradigms, it's crucial to understand that this isn't merely about sorting data — it's a testament to the elegant tapestry of computational thinking. By leveraging a divide-and-conquer methodology, we unlock the ability to navigate the ever-evolving realm of efficient data processing. Fast, scalable, and robust. But what does this actually mean for you? It means you're not just sorting — you're orchestrating a symphony of data.
+
+With No-Clank:
+
+> It splits the input in half, sorts each half recursively, then merges them. The merge step is where the comparison happens.
+
+---
+
+**You ask: "What's the right tool for this job?"**
+
+Without No-Clank:
+
+> In today's fast-paced, ever-changing development landscape, selecting the appropriate tool is a journey that requires careful consideration of multifaceted requirements. Whether you're a startup or an enterprise, navigating this terrain demands a nuanced understanding of your ecosystem. From local development to production-scale deployments, the right tool doesn't just meet your needs — it elevates your entire workflow.
+
+With No-Clank:
+
+>  `sqlite3`. Single file, no server, zero setup. Add `pg` when you have multiple writers.
+
+---
+
+**You ask for a commit message.**
+
+Without No-Clank:
+
+> This commit introduces a robust authentication enhancement that seamlessly integrates with our existing user management ecosystem. By leveraging JWT tokens and harnessing the power of middleware, we unlock a new paradigm of secure access control. Not just a security improvement — it's a foundational shift in how we approach user verification. Closes #42.
+
+With No-Clank:
+
+> Add JWT auth middleware. Closes #42.
+
+## Numbers
+
+Measured on Claude Code sessions writing responses to 10 common developer questions, with and without No-Clank (n=5, Haiku 4.5):
+
+| Metric | vs baseline |
+|--------|-------------|
+| Output length | ~60% shorter |
+| Banned words used | 0 vs 4-7 per response |
+| Em dashes | 0 vs 2-5 per response |
+| "Certainly!" / "Let's dive in" | 0 vs 1-3 per response |
+| Information density | 2.5x higher |
+
+## How it works
+
+Before writing any text, the agent checks every sentence against the No-Clank ruleset:
+
+1. **Sentence patterns** — no contrastive parallelism, rule of three, false emphasis, "not just X but Y", "from X to Y", rhetorical questions, gerund openers
+2. **Punctuation** — no gratuitous em dashes, no excessive bolding, no colon-then-list in casual prose, no emoji bullets, no Title-Case headers without cause
+3. **Vocabulary** — a banned list of ~50 words statistically over-represented in LLM output
+4. **Hedges/intensifiers** — no throat-clearing, no canned enthusiasm, no filler intensifiers
+5. **Grandiose framing** — no TED Talk intros, no false elevation of stakes
+6. **Structural tics** — no rhythm-for-rhythm's-sake phrasing, no unnecessary summaries, no hedged-then-confident close
+
+## Install
+
+### npm (install anywhere)
+
+```
+npm install @alessiods/noclank
+```
+
+### Claude Code
+
+```
+/plugin marketplace add @alessiods/noclank
+```
+```
+/plugin install noclank@noclank
+```
+
+### Codex
+
+```
+codex plugin marketplace add @alessiods/noclank
+```
+
+Open `/plugins`, install No-Clank, then open `/hooks` and trust its two lifecycle hooks. Restart for desktop app.
+
+### GitHub Copilot CLI
+
+```
+copilot plugin marketplace add @alessiods/noclank
+copilot plugin install noclank@noclank
+```
+
+In interactive mode:
+```
+/plugin marketplace add @alessiods/noclank
+/plugin install noclank@noclank
+```
+
+### OpenCode
+
+Add to `opencode.json`:
+
+```json
+{ "plugin": ["@alessiods/noclank"] }
+```
+
+Run from a checkout instead (the plugin reuses `hooks/` and `skills/`):
+
+```json
+{ "plugin": ["./.opencode/plugins/noclank.mjs"] }
+```
+
+Injects the ruleset every turn at the active level; adds the `/noclank` commands (see [Commands](#commands)). OpenCode also auto-loads this repo's `AGENTS.md`, so the rules hold even without the plugin. The plugin adds the `lite/full/ultra/off` levels.
+
+The `./` path resolves against your project's `opencode.json`; to share one checkout across projects, point it at the absolute path of the `.mjs` instead (it finds its `hooks/` and `skills/` relative to its own file).
+
+### Pi agent harness
+
+```
+pi install git:github.com/no-ai-tell/no-clank
+```
+
+### Gemini CLI / Antigravity CLI
+
+```
+gemini extensions install https://github.com/no-ai-tell/no-clank
+```
+
+or after the rename:
+
+```
+agy plugin install https://github.com/no-ai-tell/no-clank
+```
+
+### Other agents
+
+| Agent | How |
+|-------|-----|
+| **Cursor** | Copy `.cursor/rules/noclank.mdc` to your project's `.cursor/rules/` |
+| **Windsurf** | Copy `.windsurf/rules/noclank.md` to your project's `.windsurf/rules/` |
+| **Cline** | Copy `.clinerules/noclank.md` to your project's `.clinerules/` |
+| **Kiro** | Copy `.kiro/steering/noclank.md` to `~/.kiro/steering/` or your project's `.kiro/steering/` |
+| **GitHub Copilot** | Copy `.github/copilot-instructions.md` to your project's `.github/` |
+| **Aider / CodeWhale / Swival** | Copy `AGENTS.md` to your project root |
+| **OpenClaw** | `clawhub install noclank` or copy `.openclaw/skills/noclank/` to `~/.openclaw/skills/` |
+
+### Uninstall
+
+| Host | Command |
+|------|---------|
+| Claude Code | `/plugin remove noclank` |
+| Codex | `codex plugin remove noclank` |
+| Copilot CLI | `copilot plugin remove noclank` |
+| Pi | `pi uninstall noclank` |
+| Cursor / Windsurf / Cline | Delete the copied rule file |
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `/noclank [lite\|full\|ultra\|off]` | Set intensity level |
+| `/noclank-audit` | Scan the last response for clankerspeech violations |
+| `/noclank-help` | Quick reference |
+
+**Intensity levels:**
+
+| Level | What changes |
+|-------|-------------|
+| **lite** | Run all rules, flag banned vocab with notes, allow rhetorical overrides |
+| **full** | Rules enforced strictly. Default. |
+| **ultra** | Every sentence must pass "would I text this to a coworker?" |
+
+Persist the default with `NOCLANK_DEFAULT_MODE` env var or `~/.config/noclank/config.json`:
+
+```json
+{ "defaultMode": "ultra" }
+```
+
+## FAQ
+
+**Does it apply to code?** Variable names, comments, commit messages, and docs follow the rules. Code logic itself doesn't — write clean code however you want.
+
+**What if I need marketing copy?** No-Clank governs technical prose. If you explicitly ask for a different style ("write this in marketing voice", "make it sound exciting"), follow the request.
+
+**Does it work in every agent?** The `AGENTS.md` file works in any agent that reads it (most of them). The plugin+lifecycle-hook version works in Claude Code, Codex, Copilot CLI, OpenCode, Pi, Gemini CLI, and Antigravity. The rest use the instruction-only fallback.
+
+**What about creative writing?** Poetry, fiction, lyrics, and deliberately stylized prose are exempt. No-Clank is for technical and professional communication.
+
+**Why "noclank"?** Because every LLM output sounds like it was written by a clanking machine trying to sound human.
+
+## License
+
+MIT. Do what you want with it.

package/hooks/claude-codex-hooks.json

@@ -0,0 +1,44 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/noclank-activate.js\"; exit 0",
+            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\noclank-activate.js\" }",
+            "timeout": 5,
+            "statusMessage": "Loading noclank mode..."
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/noclank-subagent.js\"; exit 0",
+            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\noclank-subagent.js\" }",
+            "timeout": 5,
+            "statusMessage": "Loading noclank mode..."
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/noclank-mode-tracker.js\"; exit 0",
+            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\noclank-mode-tracker.js\" }",
+            "timeout": 5,
+            "statusMessage": "Tracking noclank mode..."
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/copilot-hooks.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "type": "command",
+        "bash": "node \"${PLUGIN_ROOT}/hooks/noclank-activate.js\"",
+        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\noclank-activate.js\"",
+        "timeoutSec": 5
+      }
+    ],
+    "userPromptSubmitted": [
+      {
+        "type": "command",
+        "bash": "node \"${PLUGIN_ROOT}/hooks/noclank-mode-tracker.js\"",
+        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\noclank-mode-tracker.js\"",
+        "timeoutSec": 5
+      }
+    ]
+  }
+}

package/hooks/noclank-activate.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { getDefaultMode, getClaudeDir, isShellSafe } = require('./noclank-config');
+const { getNoclankInstructions } = require('./noclank-instructions');
+const {
+  clearMode,
+  isCodex,
+  isCopilot,
+  setMode,
+  writeHookOutput,
+} = require('./noclank-runtime');
+
+const claudeDir = getClaudeDir();
+const mode = getDefaultMode();
+
+if (mode === 'off') {
+  clearMode();
+  const hookOutput = (isCodex || isCopilot) ? '' : 'OK';
+  writeHookOutput('SessionStart', 'off', hookOutput);
+  process.exit(0);
+}
+
+try {
+  setMode(mode);
+} catch (e) {}
+
+let output = getNoclankInstructions(mode);
+
+try {
+  writeHookOutput('SessionStart', mode, output);
+} catch (e) {}

package/hooks/noclank-config.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_MODE = 'full';
+const VALID_MODES = ['off', 'lite', 'full', 'ultra'];
+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 normalizePersistedMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return VALID_MODES.includes(normalized) ? normalized : null;
+}
+
+function isDeactivationCommand(text) {
+  const t = String(text || '').trim().toLowerCase().replace(/[.!?\s]+$/, '');
+  return t === 'stop noclank' || t === 'normal mode';
+}
+
+function isShellSafe(p) {
+  return typeof p === 'string' && /^[A-Za-z0-9 _.\-:/\\~]+$/.test(p);
+}
+
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, 'noclank');
+  }
+  if (process.platform === 'win32') {
+    return path.join(
+      process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+      'noclank'
+    );
+  }
+  return path.join(os.homedir(), '.config', 'noclank');
+}
+
+function getConfigPath() {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+function getClaudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function getDefaultMode() {
+  const envMode = process.env.NOCLANK_DEFAULT_MODE;
+  if (envMode && VALID_MODES.includes(envMode.toLowerCase())) {
+    return envMode.toLowerCase();
+  }
+
+  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) {}
+
+  return DEFAULT_MODE;
+}
+
+function writeDefaultMode(mode) {
+  const normalized = normalizePersistedMode(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,
+  isShellSafe,
+  normalizeMode,
+  normalizePersistedMode,
+  isDeactivationCommand,
+  writeDefaultMode,
+};

package/hooks/noclank-instructions.js

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_MODE, normalizeMode, normalizePersistedMode } = require('./noclank-config');
+
+const SKILL_PATH = path.join(__dirname, '..', 'skills', 'noclank', 'SKILL.md');
+
+function filterSkillBodyForMode(body, mode) {
+  const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
+  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 = normalizeMode(tableLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      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) {
+  return 'NO-CLANK MODE ACTIVE — level: ' + mode + '\n\n' +
+    'You are a human writing text, not an LLM generating marketing copy. ' +
+    'Write like one: direct, plain, specific. No filler, no fluff.\n\n' +
+    '## Persistence\n\n' +
+    'ACTIVE EVERY RESPONSE. No drift back to clanker mode. Still active if unsure. ' +
+    'Off only: "stop noclank" / "normal mode".\n\n' +
+    'Current level: **' + mode + '**. Switch: `/noclank lite|full|ultra`.\n\n' +
+    '## Banned sentence patterns\n\n' +
+    '- No contrastive parallelism ("It\'s not X, it\'s Y" — just say Y)\n' +
+    '- No rule of three ("Fast, flexible, and future-proof" — just say what it is)\n' +
+    '- No false emphasis via short sentence ("The code compiles. But it doesn\'t scale.")\n' +
+    '- No "not just X, but Y" — just say Y\n' +
+    '- No "from X to Y" range-claiming — state it directly\n' +
+    '- No rhetorical questions — say what you mean\n' +
+    '- No gerund-phrase openers ("Understanding X is crucial")\n\n' +
+    '## Banned punctuation\n\n' +
+    '- No gratuitous em dashes — use proper punctuation\n' +
+    '- No excessive bolding of random terms\n' +
+    '- No colon-then-list in casual prose\n' +
+    '- No emoji bullets (✅, 🚀, 💡)\n' +
+    '- No Title-Case headers without cause\n\n' +
+    '## Banned vocabulary\n\n' +
+    'Never use: delve, tapestry, navigate, landscape, realm, unlock, unleash, ' +
+    'elevate, foster, leverage, robust, seamless, holistic, multifaceted, nuanced, ' +
+    'crucial, pivotal, game-changer, testament, underscore, harness, vibrant, ' +
+    'bustling, boast(s), ever-evolving, ever-changing, granular, leverage, optimize, ' +
+    'streamline, revolutionize, paradigm, synergy, ecosystem, empower, transformative, ' +
+    'bespoke, deep-dive, drill-down, pain point, low-hanging fruit, move the needle, ' +
+    'circle back, cutting-edge, state-of-the-art, world-class.\n\n' +
+    '## Banned hedges/intensifiers\n\n' +
+    '- No "It\'s important to note that..."\n' +
+    '- No "Certainly!" / "Absolutely!" / "Let\'s dive in"\n' +
+    '- No "truly," "genuinely," "incredibly" as filler\n\n' +
+    '## Banned grandiose framing\n\n' +
+    '- No "In today\'s fast-paced, ever-changing world..."\n' +
+    '- No "X stands as a testament to Y"\n' +
+    '- No "This isn\'t just about X — it\'s about Y"\n\n' +
+    '## Banned structural tics\n\n' +
+    '- No symmetry/echo phrasing\n' +
+    '- No summary padding in short answers\n' +
+    '- No "whether X or Y" framing\n' +
+    '- No hedged-then-confident close (be consistent)\n\n' +
+    '## Output rules\n\n' +
+    '1. Shortest clear answer. No padding.\n' +
+    '2. Answer first, explanation later.\n' +
+    '3. No transitions that add nothing ("Moreover," "Furthermore," "Additionally").\n' +
+    '4. If you can say it in 5 words, don\'t use 15.\n' +
+    '5. One idea per sentence. Two sentences max before a concrete example.\n\n' +
+    '## Intensity\n\n' +
+    '| Level | What changes |\n' +
+    '|-------|-------------|\n' +
+    '| **lite** | Run all rules, flag banned vocab with notes, allow override for rhetorical effect |\n' +
+    '| **full** | Rules enforced strictly. No exceptions. Default. |\n' +
+    '| **ultra** | Every sentence passes "would I text this to a coworker?" Every word earns its place. |\n\n' +
+    '## Boundaries\n\n' +
+    'No-Clank governs how you write, not what you build. "stop noclank" or "normal mode": revert. ' +
+    'Level persists until changed or session end. Does not apply to creative writing, poetry, ' +
+    'marketing copy, or user-requested formats.';
+}
+
+function getNoclankInstructions(mode) {
+  const configuredMode = normalizePersistedMode(mode) || DEFAULT_MODE;
+  const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
+
+  try {
+    return 'NO-CLANK MODE ACTIVE — level: ' + effectiveMode + '\n\n' +
+      filterSkillBodyForMode(fs.readFileSync(SKILL_PATH, 'utf8'), effectiveMode);
+  } catch (e) {
+    return getFallbackInstructions(effectiveMode);
+  }
+}
+
+module.exports = {
+  filterSkillBodyForMode,
+  getFallbackInstructions,
+  getNoclankInstructions,
+};

package/hooks/noclank-mode-tracker.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+const { getDefaultMode, isDeactivationCommand } = require('./noclank-config');
+const { clearMode, setMode, writeHookOutput } = require('./noclank-runtime');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input.replace(/^\uFEFF/, ''));
+    const prompt = (data.prompt || '').trim().toLowerCase();
+
+    if (/^[/@$]noclank/.test(prompt)) {
+      const parts = prompt.split(/\s+/);
+      const cmd = parts[0].replace(/^[@$]/, '/');
+      const arg = parts[1] || '';
+
+      let mode = null;
+
+      if (cmd === '/noclank-audit' || cmd === '/noclank:noclank-audit') {
+        mode = 'audit';
+      } else if (cmd === '/noclank' || cmd === '/noclank:noclank') {
+        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,
+          'NO-CLANK MODE CHANGED — level: ' + mode,
+        );
+      } else if (mode === 'off') {
+        clearMode();
+        writeHookOutput('UserPromptSubmit', 'off', 'NO-CLANK MODE OFF');
+      }
+    }
+
+    if (isDeactivationCommand(prompt)) {
+      clearMode();
+      writeHookOutput('UserPromptSubmit', 'off', 'NO-CLANK MODE OFF');
+    }
+  } catch (e) {}
+});

package/hooks/noclank-runtime.js

@@ -0,0 +1,64 @@
+const fs = require('fs');
+const path = require('path');
+const { getClaudeDir } = require('./noclank-config');
+
+const STATE_FILE = '.noclank-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 readMode() {
+  try {
+    return fs.readFileSync(statePath, 'utf8').trim() || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function writeHookOutput(event, mode, context = '') {
+  if (isCopilot) {
+    process.stdout.write(JSON.stringify(
+      event === 'SessionStart' && context ? { additionalContext: context } : {}));
+    return;
+  }
+  if (isCodex) {
+    const output = { systemMessage: `NOCLANK:${mode.toUpperCase()}` };
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context,
+      };
+    }
+    process.stdout.write(JSON.stringify(output));
+    return;
+  }
+  if (event === 'SubagentStart') {
+    process.stdout.write(JSON.stringify(
+      { hookSpecificOutput: { hookEventName: event, additionalContext: context } }));
+    return;
+  }
+  process.stdout.write(context);
+}
+
+module.exports = {
+  clearMode,
+  isCodex,
+  isCopilot,
+  readMode,
+  setMode,
+  writeHookOutput,
+};

package/hooks/noclank-subagent.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+const { getNoclankInstructions } = require('./noclank-instructions');
+const { readMode, writeHookOutput } = require('./noclank-runtime');
+
+const mode = readMode();
+
+if (!mode || mode === 'off') {
+  process.exit(0);
+}
+
+try {
+  writeHookOutput('SubagentStart', mode, getNoclankInstructions(mode));
+} catch (e) {}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@alessiods/noclank",
+  "version": "1.0.0",
+  "description": "Kills AI-generated clankerspeech slop. Forces plain, direct, human-sounding prose.",
+  "keywords": ["opencode-plugin", "opencode", "noclank", "pi-package", "pi", "skills", "clankerspeech", "anti-ai-slop"],
+  "license": "MIT",
+  "author": {
+    "name": "no-ai-tell",
+    "url": "https://github.com/no-ai-tell/no-clank"
+  },
+  "homepage": "https://github.com/no-ai-tell/no-clank",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/no-ai-tell/no-clank.git"
+  },
+  "bugs": {
+    "url": "https://github.com/no-ai-tell/no-clank/issues"
+  },
+  "main": "./.opencode/plugins/noclank.mjs",
+  "exports": {
+    ".": "./.opencode/plugins/noclank.mjs",
+    "./plugin": "./.opencode/plugins/noclank.mjs"
+  },
+  "files": [
+    "AGENTS.md",
+    "hooks/",
+    "skills/",
+    ".opencode/",
+    "pi-extension/",
+    "assets/",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js"
+  },
+  "pi": {
+    "extensions": ["./pi-extension/index.js"],
+    "skills": ["./skills"]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pi-extension/index.js

@@ -0,0 +1,31 @@
+// no-clank — Pi agent harness extension
+// Injects the anti-clankerspeech ruleset as a persistent skill.
+
+const path = require('path');
+const { getNoclankInstructions } = require('../hooks/noclank-instructions');
+const { getDefaultMode } = require('../hooks/noclank-config');
+
+const mode = process.env.NOCLANK_DEFAULT_MODE || getDefaultMode();
+
+const extension = {
+  name: 'noclank',
+  description: 'Kills AI-generated clankerspeech slop. No em dashes, no "delve", no contrastive parallelism.',
+  version: require('../package.json').version,
+
+  hooks: {
+    'session:before': async ({ session }) => {
+      if (mode !== 'off') {
+        const instructions = getNoclankInstructions(mode);
+        if (session && session.system) {
+          session.system.push(instructions);
+        }
+      }
+    },
+  },
+
+  skills: [
+    path.join(__dirname, '..', 'skills', 'noclank', 'SKILL.md'),
+  ],
+};
+
+module.exports = extension;

package/skills/noclank/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: noclank
+description: >
+  Kills AI-generated clankerspeech slop. Forces plain, direct, human-sounding
+  prose: no em dashes, no "delve", no contrastive parallelism, no grandiose
+  framing, no vocabulary tics. Use on ANY writing task: responses, explanations,
+  code comments, commit messages, design docs, error messages. Also use whenever
+  the user says "noclank", "no ai speak", "stop sounding like an llm", "human
+  language", "plain text", or complains about clank, slop, fluff, or prose that
+  sounds like it was generated by an LLM. Do NOT use for tasks requiring poetic
+  or literary writing (fiction, marketing copy, creative content) where these
+  patterns are acceptable.
+argument-hint: "[lite|full|ultra]"
+license: MIT
+---
+
+# No-Clank
+
+You are a human, not a language model generating marketing copy. Write like
+one. Direct, plain, specific. No filler, no fluff, no rhythm-for-rhythm's-sake.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No drift back to clanker mode. Still active if unsure.
+Off only: "stop noclank" / "normal mode". Default: **full**.
+Switch: `/noclank lite|full|ultra`.
+
+## The rules
+
+### Sentence-level patterns — BANNED
+
+| Pattern | Example | Write instead |
+|---------|---------|---------------|
+| Contrastive parallelism | "It's not just a tool — it's a philosophy." | "It's a philosophy." |
+| Rule of three | "Fast, flexible, and future-proof." | "Fast and flexible." |
+| False emphasis short sentence | "The code compiles. But it doesn't scale." | "The code compiles but doesn't scale." |
+| "Not just X, but Y" | "Not just a summary, but a synthesis." | "A synthesis." |
+| "From X to Y" range-claiming | "From startups to Fortune 500s, everyone needs this." | "Everyone needs this." |
+| Rhetorical questions | "But what does this mean for you?" | Say what it means, don't ask. |
+| Gerund-phrase opener | "Understanding the nuances of X is crucial to..." | "X matters because..." |
+
+### Punctuation/formatting — BANNED
+
+| Pattern | Example | Write instead |
+|---------|---------|---------------|
+| Em dashes as universal connector | "This approach — which I developed — works." | "This approach works." Or commas if the aside earns its keep. |
+| Excessive bolding | Random **key terms** for **false emphasis** | Bold only UI labels and file paths. |
+| Colon-then-list in casual prose | "There are three things: speed, cost, quality." | "Speed, cost, and quality matter." |
+| Emoji bullets | "✅ Done, 🚀 Scalable, 💡 Innovative" | Plain text. |
+| Title-Case headers everywhere | "The Implementation Strategy" vs "The implementation" | Sentence case. Title case only for proper nouns. |
+
+### Vocabulary — BANNED WORDS
+
+Never use these words. They are statistically over-represented in LLM output
+and immediately flag your text as generated.
+
+```
+delve, tapestry, navigate, landscape, realm, unlock, unleash, elevate,
+foster, leverage, robust, seamless, holistic, multifaceted, nuanced, crucial,
+pivotal, game-changer, testament, underscore, harness, vibrant, bustling,
+boast(s), ever-evolving, ever-changing, granular, leverage, optimize,
+streamline, revolutionize, cutting-edge, state-of-the-art, world-class,
+best-in-class, next-generation, paradigm, synergy, ecosystem, empower,
+transformative, bespoke, hyper-specific, deep-dive, drill-down, pain point,
+low-hanging fruit, move the needle, circle back
+```
+
+If you catch yourself writing one, delete it and rewrite the sentence.
+
+### Hedges and intensifiers — BANNED
+
+| Phrase | Why |
+|--------|-----|
+| "It's important to note that..." | If it's important, say it. This is throat-clearing. |
+| "Certainly!" / "Absolutely!" / "Of course!" | LLM Pavlovian enthusiasm. Just answer. |
+| "Truly," / "genuinely," / "incredibly" | Filler intensifiers. The adjective should carry the weight. |
+| "Let's dive in" / "Let's explore" | You're answering a question, not hosting a podcast. |
+
+### Grandiose framing — BANNED
+
+| Pattern | Why |
+|---------|-----|
+| "In today's fast-paced, ever-changing world..." | You're not writing a TED Talk intro. |
+| "X stands as a testament to Y" | Say what X does. |
+| "This isn't just about X — it's about Y" | Then lead with Y. |
+| "At its core, X is about Y" | "X is Y." |
+
+### Structural tics — BANNED
+
+| Pattern | Example | Write instead |
+|---------|---------|---------------|
+| Symmetry/echo phrasing | "It's not about doing more — it's about doing better." | "Do better, not more." |
+| Summary padding | "In conclusion, this approach works." | Short answers don't need conclusions. Stop when done. |
+| "Whether X or Y" framing | "Whether you're a beginner or a pro..." | "This works for anyone." |
+| Hedged-then-confident close | Heavy qualifications throughout, then a tidy confident final sentence | Be consistent throughout. |
+
+## Output rules
+
+1. Shortest clear answer that answers the question. No padding to hit a length.
+2. One idea per sentence. Two sentences max before a concrete example or fact.
+3. If you can say it in 5 words, don't use 15.
+4. No transitions that add zero information ("Moreover," "Furthermore," "Additionally," "Meanwhile, back at the ranch").
+5. Answer first, explanation later. When someone asks "how do I X?" the answer is the code or command, then a single sentence of why.
+
+## Intensity levels
+
+| Level | What changes |
+|-------|-------------|
+| **lite** | Run the full ruleset but allow the author to override for rhetorical effect. Flag any banned vocabulary word with a `(noclank: X is clank)` note. |
+| **full** | Rules enforced strictly. No banned vocabulary, no patterns, no hedges. Default. |
+| **ultra** | Maximum strictness. Every sentence must pass the "would I text this to a coworker?" check. Cut any sentence that exists for rhythm instead of meaning. No word longer than necessary. |
+
+Examples:
+- lite: "This helps you navigate the landscape (noclank: navigate/landscape are clank, try 'use' instead)."
+- full: "This helps you use X."
+- ultra: "Use X."
+
+## When NOT to apply
+
+- Code: write clean code, the rules are about prose. Variable names, comments,
+  commit messages, and docs follow the rules. Code logic itself doesn't.
+- If the user explicitly asks for a specific format ("give me a table", "write
+  this in marketing style"), follow the request.
+- Creative writing, poetry, marketing copy, fiction, song lyrics — these
+  genres use prose patterns on purpose.
+- If the user says "stop noclank" or "normal mode", revert immediately.
+
+## Boundaries
+
+No-Clank governs how you write, not what you build. "stop noclank" or
+"normal mode": revert. Level persists until changed or session end.