@wrongstack/plugins 0.277.2 → 0.280.1

package/dist/commit-validator.js

@@ -0,0 +1,315 @@
+// src/commit-validator/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  validCount: 0,
+  invalidCount: 0,
+  hookUnregister: null,
+  lastValidation: null
+};
+var DEFAULTS = {
+  mode: "block",
+  requireScope: false,
+  allowedTypes: [],
+  maxSubjectLength: 72,
+  bodyRequired: false,
+  minBodyLength: 10
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    mode: r["mode"] === "warn" ? "warn" : "block",
+    requireScope: r["requireScope"] === true,
+    allowedTypes: Array.isArray(r["allowedTypes"]) ? r["allowedTypes"].filter((x) => typeof x === "string") : [],
+    maxSubjectLength: typeof r["maxSubjectLength"] === "number" && r["maxSubjectLength"] > 0 ? r["maxSubjectLength"] : DEFAULTS.maxSubjectLength,
+    bodyRequired: r["bodyRequired"] === true,
+    minBodyLength: typeof r["minBodyLength"] === "number" && r["minBodyLength"] > 0 ? r["minBodyLength"] : DEFAULTS.minBodyLength
+  };
+}
+var STANDARD_TYPES = [
+  "feat",
+  "fix",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "build",
+  "ci",
+  "chore",
+  "revert"
+];
+function parseCommitMessage(message, cfg) {
+  const errors = [];
+  const firstLine = message.trim().split("\n")[0] ?? "";
+  if (!firstLine) {
+    return { valid: false, type: "", scope: "", subject: "", breaking: false, errors: ["empty commit message"] };
+  }
+  const match = firstLine.match(/^([a-zA-Z]+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/);
+  if (!match) {
+    errors.push(
+      `Message does not match conventional-commit format: "<type>[(scope)][!]: <description>". Got: "${firstLine.slice(0, 60)}"`
+    );
+    return { valid: false, type: "", scope: "", subject: firstLine, breaking: false, errors };
+  }
+  const [, typeRaw, scopeRaw, breakingRaw, subjectRaw] = match;
+  const type = (typeRaw ?? "").toLowerCase();
+  const scope = scopeRaw ?? "";
+  const breaking = breakingRaw === "!";
+  const subject = subjectRaw ?? "";
+  if (!type) {
+    errors.push("Missing commit type (e.g. feat, fix, docs).");
+  } else if (cfg.allowedTypes.length > 0 && !cfg.allowedTypes.includes(type)) {
+    errors.push(
+      `Type "${type}" is not in allowedTypes: ${cfg.allowedTypes.join(", ")}. Standard types: ${STANDARD_TYPES.join(", ")}.`
+    );
+  } else if (cfg.allowedTypes.length === 0 && !STANDARD_TYPES.includes(type)) ;
+  if (cfg.requireScope && !scope) {
+    errors.push("A scope is required (e.g. feat(auth): ...).");
+  }
+  if (!subject) {
+    errors.push("Missing subject description after the colon.");
+  }
+  if (subject.length > cfg.maxSubjectLength) {
+    errors.push(
+      `Subject is ${subject.length} characters \u2014 exceeds maxSubjectLength of ${cfg.maxSubjectLength}. Move details to the body.`
+    );
+  }
+  if (subject.endsWith(".")) {
+    errors.push("Subject should not end with a period.");
+  }
+  if (cfg.bodyRequired) {
+    const lines = message.trim().split("\n");
+    const bodyStart = lines.findIndex((line, i) => i > 0 && line.trim() === "");
+    const body = bodyStart >= 0 ? lines.slice(bodyStart + 1).join("\n").trim() : "";
+    if (!body) {
+      errors.push("A commit body is required. Add a blank line after the subject, then the description.");
+    } else if (body.length < cfg.minBodyLength) {
+      errors.push(
+        `Body is ${body.length} characters \u2014 minimum is ${cfg.minBodyLength}. Add more context about what changed and why.`
+      );
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    type,
+    scope,
+    subject,
+    breaking,
+    errors
+  };
+}
+function extractMessageFromBash(command) {
+  const flags = [];
+  const doubleQuoted = command.matchAll(/-m\s+"([^"]*)"/g);
+  const singleQuoted = command.matchAll(/-m\s+'([^']*)'/g);
+  for (const m of doubleQuoted) flags.push(m[1] ?? "");
+  for (const m of singleQuoted) flags.push(m[1] ?? "");
+  if (flags.length === 0) return null;
+  return flags.join("\n");
+}
+var plugin = {
+  name: "commit-validator",
+  version: "0.1.0",
+  description: "PreToolUse hook that validates conventional-commit format before git_autocommit or bash git commit runs",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      mode: {
+        type: "string",
+        enum: ["block", "warn"],
+        default: "block",
+        description: '"block" refuses the commit; "warn" injects errors as context but lets it through.'
+      },
+      requireScope: {
+        type: "boolean",
+        default: false,
+        description: "Require a scope in parentheses (e.g. feat(auth): ...)."
+      },
+      allowedTypes: {
+        type: "array",
+        items: { type: "string" },
+        default: [],
+        description: "Restrict to these commit types. Empty = allow all standard types (feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert) plus any custom type."
+      },
+      maxSubjectLength: {
+        type: "number",
+        minimum: 10,
+        default: 72,
+        description: "Maximum subject line length in characters."
+      },
+      bodyRequired: {
+        type: "boolean",
+        default: false,
+        description: "Require a non-empty commit body after the subject line."
+      },
+      minBodyLength: {
+        type: "number",
+        minimum: 1,
+        default: 10,
+        description: "Minimum body length in characters (when bodyRequired is true)."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.validCount = 0;
+    state.invalidCount = 0;
+    state.hookUnregister = null;
+    state.lastValidation = null;
+    const cfg = readConfig(api.config.extensions?.["commit-validator"]);
+    const hook = (input) => {
+      const toolName = input.toolName ?? "";
+      const inp = input.toolInput ?? {};
+      let message = null;
+      if (toolName === "git_autocommit") {
+        message = inp["message"] ?? null;
+        if (!message) {
+          const type = inp["type"];
+          if (type && cfg.allowedTypes.length > 0 && !cfg.allowedTypes.includes(type)) {
+            state.invocationCount += 1;
+            state.invalidCount += 1;
+            state.lastValidation = {
+              tool: toolName,
+              valid: false,
+              type,
+              scope: "",
+              subject: "",
+              errors: [`Type "${type}" is not in allowedTypes: ${cfg.allowedTypes.join(", ")}`],
+              when: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            if (cfg.mode === "block") {
+              return {
+                decision: "block",
+                reason: `commit-validator: type "${type}" is not allowed. Allowed: ${cfg.allowedTypes.join(", ")}.`
+              };
+            }
+            return {
+              decision: "allow",
+              additionalContext: `
+\u26A0\uFE0F commit-validator: type "${type}" is not in allowedTypes.`
+            };
+          }
+          return;
+        }
+      } else if (toolName === "bash") {
+        const command = inp["command"];
+        if (typeof command !== "string") return;
+        if (!/\bgit\s+commit\b/.test(command)) return;
+        message = extractMessageFromBash(command);
+        if (!message) return;
+      } else {
+        return;
+      }
+      state.invocationCount += 1;
+      const parsed = parseCommitMessage(message, cfg);
+      state.lastValidation = {
+        tool: toolName,
+        valid: parsed.valid,
+        type: parsed.type,
+        scope: parsed.scope,
+        subject: parsed.subject,
+        errors: parsed.errors,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (parsed.valid) {
+        state.validCount += 1;
+        return;
+      }
+      state.invalidCount += 1;
+      const errorList = parsed.errors.map((e) => `  \u2022 ${e}`).join("\n");
+      const example = `feat: add user authentication
+  fix(api): correct response parsing
+  docs: update README`;
+      if (cfg.mode === "block") {
+        return {
+          decision: "block",
+          reason: `commit-validator: invalid conventional-commit message.
+Errors:
+${errorList}
+
+Expected format: <type>[(scope)][!]: <description>
+Examples:
+  ${example}`
+        };
+      }
+      return {
+        decision: "allow",
+        additionalContext: `
+\u26A0\uFE0F commit-validator: commit message has ${parsed.errors.length} issue(s):
+${errorList}
+Expected: <type>[(scope)][!]: <description>`
+      };
+    };
+    state.hookUnregister = api.registerHook("PreToolUse", "bash|git_autocommit", hook);
+    api.tools.register({
+      name: "commit_validator_status",
+      description: "Reports commit-validator state: mode, allowedTypes, maxSubjectLength, and per-session valid/invalid counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Git",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          mode: cfg.mode,
+          requireScope: cfg.requireScope,
+          allowedTypes: cfg.allowedTypes,
+          maxSubjectLength: cfg.maxSubjectLength,
+          bodyRequired: cfg.bodyRequired,
+          minBodyLength: cfg.minBodyLength,
+          standardTypes: STANDARD_TYPES,
+          counters: {
+            invocations: state.invocationCount,
+            valid: state.validCount,
+            invalid: state.invalidCount
+          },
+          lastValidation: state.lastValidation
+        };
+      }
+    });
+    api.log.info("commit-validator plugin loaded", {
+      version: "0.1.0",
+      mode: cfg.mode,
+      requireScope: cfg.requireScope
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocationCount,
+      valid: state.validCount,
+      invalid: state.invalidCount
+    };
+    state.invocationCount = 0;
+    state.validCount = 0;
+    state.invalidCount = 0;
+    state.lastValidation = null;
+    api.log.info("commit-validator: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastValidation === null ? `commit-validator: ${state.invocationCount} validation(s), ${state.validCount} valid, ${state.invalidCount} invalid` : state.lastValidation.valid ? `commit-validator: last commit "${state.lastValidation.type}: ${state.lastValidation.subject.slice(0, 40)}" was valid` : `commit-validator: last commit was invalid (${state.lastValidation.errors.length} error(s)) at ${state.lastValidation.when}`,
+      counters: {
+        invocations: state.invocationCount,
+        valid: state.validCount,
+        invalid: state.invalidCount
+      },
+      lastValidation: state.lastValidation
+    };
+  }
+};
+var commit_validator_default = plugin;
+
+export { commit_validator_default as default };

package/dist/config-validator.d.ts

@@ -0,0 +1,48 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * config-validator plugin — instant syntax feedback after config-file
+ * writes.
+ *
+ * A broken `package.json` or malformed YAML often goes unnoticed
+ * until a later build fails with an unrelated-looking error. This
+ * plugin validates config files immediately: a `PostToolUse` hook on
+ * `write|edit` re-reads the target file from disk (what actually
+ * landed, not what the tool intended) and reports problems via
+ * `additionalContext` in the same turn:
+ *
+ *  - `.json` / `.jsonc`      → strict parse (JSONC comments stripped
+ *    first); parse errors include the line/column
+ *  - `package.json`          → parse + shape checks (name/version
+ *    present, `dependencies` is an object)
+ *  - `.yaml` / `.yml`        → structural lint: tab indentation
+ *    (illegal in YAML), duplicate keys at the same indent within a
+ *    block, unclosed quotes
+ *  - `.toml`                 → duplicate table headers, duplicate
+ *    keys within a table
+ *
+ * Valid files produce no output — zero noise on the happy path.
+ *
+ * Config (`config.extensions['config-validator']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "extensions": [".json", ".jsonc", ".yaml", ".yml", ".toml"],
+ *   "maxFileBytes": 1048576
+ * }
+ * ```
+ *
+ * Toggle off with `{ "name": "config-validator", "enabled": false }`
+ * in `config.plugins`, or `"enabled": false` in the options above.
+ *
+ * @public
+ */
+
+declare function validateJson(text: string, isJsonc: boolean, fileName: string): string[];
+declare function validateYaml(text: string): string[];
+declare function validateToml(text: string): string[];
+declare function validateFile(path: string, text: string): string[];
+declare const plugin: Plugin;
+
+export { plugin as default, validateFile, validateJson, validateToml, validateYaml };