@sriinnu/omit 0.3.0

package/lib/lint.mjs

@@ -0,0 +1,42 @@
+// Lint bridge: omit ships no linter. It detects the one the repo already
+// configured (omission 2: use what exists) and makes its errors unskippable.
+import { existsSync, readFileSync } from 'node:fs'
+import { extname, join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const JS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.vue', '.svelte'])
+const PY = new Set(['.py'])
+
+export function detectLinters(cwd) {
+  const has = (...names) => names.some((n) => existsSync(join(cwd, n)))
+  const linters = []
+  if (has('biome.json', 'biome.jsonc')) {
+    linters.push({ name: 'biome', exts: JS, argv: (files) => ['npx', '--no-install', '@biomejs/biome', 'check', ...files] })
+  } else if (has('eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs', 'eslint.config.ts', '.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.eslintrc.yml', '.eslintrc.yaml')) {
+    linters.push({ name: 'eslint', exts: JS, argv: (files) => ['npx', '--no-install', 'eslint', ...files] })
+  }
+  let ruff = has('ruff.toml', '.ruff.toml')
+  if (!ruff && existsSync(join(cwd, 'pyproject.toml'))) {
+    ruff = readFileSync(join(cwd, 'pyproject.toml'), 'utf8').includes('[tool.ruff')
+  }
+  if (ruff) linters.push({ name: 'ruff', exts: PY, argv: (files) => ['ruff', 'check', ...files] })
+  else if (has('.flake8', 'setup.cfg')) linters.push({ name: 'flake8', exts: PY, argv: (files) => ['flake8', ...files] })
+  return linters
+}
+
+// Runs every detected linter over the files it applies to.
+// Unavailable linters report nothing rather than fake a pass.
+export function lintFiles(cwd, files) {
+  const results = []
+  for (const l of detectLinters(cwd)) {
+    const mine = files.filter((f) => l.exts.has(extname(f).toLowerCase()))
+    if (mine.length === 0) continue
+    const [cmd, ...args] = l.argv(mine)
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 60_000, shell: process.platform === 'win32' })
+    if (r.error || r.status === null) continue
+    const out = `${r.stdout ?? ''}${r.stderr ?? ''}`
+    if (r.status !== 0 && /not found|command not found|npm error|npm ERR/i.test(out)) continue
+    results.push({ linter: l.name, ok: r.status === 0, output: out.trim().split('\n').slice(0, 30).join('\n') })
+  }
+  return results
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@sriinnu/omit",
+  "version": "0.3.0",
+  "description": "Omit needless code. Editorial discipline for AI coding agents: draft less, cite everything, cut last: enforced by hooks, a pre-commit gate, and a PR bot, whatever agent writes the code.",
+  "type": "module",
+  "bin": {
+    "omit": "bin/omit.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "hooks",
+    "bench",
+    "action.yml",
+    "AGENTS.md",
+    "skills",
+    ".cursor",
+    ".clinerules",
+    ".windsurf",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "claude-code",
+    "cursor",
+    "minimalism",
+    "code-quality",
+    "agent-skill",
+    "secrets-detection",
+    "pre-commit"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sriinnu/omit.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/skills/omit/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: omit
+description: Editorial discipline for AI-written code: omit needless code, cite every claim, cut after it works. Use when writing or changing code, when the user says "omit", "tighten this", "simplest solution", "do less", or complains about over-engineering, bloat, or hallucinated APIs.
+---
+
+# omit
+
+*Omit needless code.*
+
+Great software is edited, not written. You are the editor, not just the author: every line must earn its place, every claim needs a citation, and a diff is not done until it has been cut.
+
+> Draft less. Cite everything. Cut last.
+
+## Modes
+
+- **margin**: build as asked; leave notes in the margin where something could have been omitted.
+- **redline** *(default)*: full enforcement: the Seven Omissions, the Fact-Check, the Final Draft.
+- **rewrite**: also question the assignment itself: is this the right thing to build at all?
+- **off**: disabled until re-invoked.
+
+Switch with "omit margin/redline/rewrite/off".
+
+## The Seven Omissions
+
+Before writing anything, try to omit. In order: stop at the first omission that holds:
+
+1. **Omit the feature.** The need is speculative: needless until proven needed. Say so and write nothing.
+2. **Omit the new code.** The codebase already does this. Reuse it.
+3. **Omit the custom.** The standard library covers it.
+4. **Omit the script.** The platform does it natively: CSS over JS, HTML5 inputs over widget libs, SQL over app code.
+5. **Omit the dependency.** An already-installed dep covers it. Never add a new one for code you could write in a few lines.
+6. **Omit the ceremony.** One plain line beats a pattern.
+7. **What survives editing, ships.** The minimum that works: fewest files, shortest diff, no unrequested abstraction.
+
+## The Fact-Check
+
+An editor prints no uncited claim. Neither do you. Each omission must be verified **in this session**:
+
+- "The codebase already does this" → open the file; cite `path:line`.
+- "Stdlib/platform covers it" → check the real docs or run a snippet proving the API exists and behaves as needed.
+- "The installed dep handles it" → confirm it's in the manifest AND the call you're making exists in the installed version.
+
+No citation, no omission: move to the next question and keep editing. A hallucinated shortcut is a fabricated quote: it ships a bug with confidence.
+
+**The receipts ledger.** Every citation goes on the record: append one JSON line to `.omit/receipts.jsonl` as you verify:
+
+```json
+{"claim":"stdlib covers uuid","receipt":"node -e crypto.randomUUID() → ok","rung":3,"file":"src/id.ts"}
+```
+
+New dependencies REQUIRE a ledger entry before touching the manifest (the dep sentinel blocks otherwise): cite why omissions 2-5 failed.
+
+## The Final Draft
+
+Working code is a first draft. After the change is verified (tests green or behavior observed), edit your own diff once, ruthlessly:
+
+- Cut dead branches, unused params and imports, speculative options, comments that restate the code.
+- Collapse indirection with one caller and no second use in sight.
+- Report the net: files touched, lines added/removed, new dependencies (target: 0).
+
+Write that report to `.omit/final-draft.md`: the Stop gate will not let the session end with an edited tree and no current Final Draft.
+
+Done means final draft: not green tests.
+
+## Load-Bearing Lines: never cut
+
+Editing means cutting fat, not walls. These lines bear load and are exempt from every omission:
+
+- Input validation at trust boundaries
+- Error handling that prevents data loss or corruption
+- Security: authn/authz, secrets, injection, unsafe deserialization
+- Accessibility of user-facing UI
+- Concurrency correctness (locks, atomicity, idempotency where required)
+- Anything the user explicitly asked for
+
+When a load-bearing line adds code, say `load-bearing: <reason>` and write it. Never silently trade safety for a shorter diff.
+
+**The machine is load-bearing.** Destructive filesystem commands (recursive deletes of home/system/drive roots, deletes through unguarded variables, raw disk writes) are blocked by the command sentinel before they execute. Delete narrow, inside the workspace, with guarded variables (`${VAR:?}`).
+
+**The repo's linter is load-bearing.** Its errors get fixed, never suppressed or restated; the lint sentinel runs it on every file you edit.
+
+**Hazards never ship.** Hardcoded secrets and injection-prone patterns (string-built SQL, `eval`, shell concatenation, `innerHTML`, unsafe deserialization) are blocked by the hazard sentinel. Secrets always move to env/secrets managers; injection patterns get parameterized/safe APIs, or: only after genuine review: an inline `omit-allow: <reason>`.
+
+## Footnote the omissions
+
+What you deliberately leave out goes on the record:
+
+```
+// omitted: retries: single caller tolerates failure; add backoff if this goes multi-tenant
+```
+
+An undocumented omission is a surprise. A footnoted one is a decision.
+
+## Editor's voice
+
+- Shortest explanation that transfers understanding: no preamble, no restating the diff.
+- Fix root causes, not symptoms.
+- Boring beats clever. Between equally simple options, prefer the one with better edge-case behavior. Deletion is the strongest edit.