@wrongstack/plugins 0.277.1 → 0.280.0

package/dist/format-on-save.js

@@ -0,0 +1,219 @@
+import { execSync } from 'child_process';
+import { existsSync, statSync } from 'fs';
+
+// src/format-on-save/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  /** Times formatting was applied (file changed). */
+  formattedCount: 0,
+  /** Times the file was already formatted (no change). */
+  cleanCount: 0,
+  /** Times biome failed (not installed, timeout, parse error). */
+  errorCount: 0,
+  /** Hook handle for teardown. */
+  hookUnregister: null,
+  /** Last format result — surfaced by health() + status tool. */
+  lastResult: null
+};
+var DEFAULTS = {
+  enabled: true,
+  timeoutMs: 5e3
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    timeoutMs: typeof r["timeoutMs"] === "number" && r["timeoutMs"] > 0 ? r["timeoutMs"] : DEFAULTS.timeoutMs
+  };
+}
+function formatFile(filePath, timeoutMs) {
+  if (!existsSync(filePath)) return null;
+  let bytesBefore;
+  try {
+    bytesBefore = statSync(filePath).size;
+  } catch {
+    return null;
+  }
+  try {
+    execSync(`npx biome format --write "${filePath}"`, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const e = err;
+    if (e.killed) return null;
+  }
+  let bytesAfter;
+  try {
+    bytesAfter = statSync(filePath).size;
+  } catch {
+    return null;
+  }
+  if (bytesAfter !== bytesBefore) {
+    return { changed: true, bytesBefore, bytesAfter };
+  }
+  try {
+    execSync(`npx biome format "${filePath}"`, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { changed: false, bytesBefore, bytesAfter };
+  } catch {
+    return { changed: true, bytesBefore, bytesAfter };
+  }
+}
+var plugin = {
+  name: "format-on-save",
+  version: "0.1.0",
+  description: "PostToolUse hook that runs biome format --write on the file after every write or edit",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch. When false, the hook is a no-op."
+      },
+      timeoutMs: {
+        type: "number",
+        minimum: 1e3,
+        default: 5e3,
+        description: "Biome format process timeout in milliseconds."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.formattedCount = 0;
+    state.cleanCount = 0;
+    state.errorCount = 0;
+    state.hookUnregister = null;
+    state.lastResult = null;
+    const cfg = readConfig(api.config.extensions?.["format-on-save"]);
+    let biomeAvailable = false;
+    try {
+      execSync("npx biome --version", {
+        encoding: "utf-8",
+        timeout: 5e3,
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      biomeAvailable = true;
+      api.log.info("format-on-save: biome detected");
+    } catch {
+      biomeAvailable = false;
+      api.log.warn("format-on-save: biome not found \u2014 hook will be a no-op");
+    }
+    const hook = (input) => {
+      if (!cfg.enabled || !biomeAvailable) return;
+      if (input.toolResult?.isError) return;
+      const toolName = input.toolName ?? "";
+      const inp = input.toolInput ?? {};
+      const filePath = inp["path"];
+      if (!filePath || typeof filePath !== "string") return;
+      state.invocationCount += 1;
+      const result = formatFile(filePath, cfg.timeoutMs);
+      if (!result) {
+        state.errorCount += 1;
+        return;
+      }
+      state.lastResult = {
+        path: filePath,
+        tool: toolName,
+        changed: result.changed,
+        bytesBefore: result.bytesBefore,
+        bytesAfter: result.bytesAfter,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (result.changed) {
+        state.formattedCount += 1;
+        const delta = result.bytesAfter - result.bytesBefore;
+        api.log.info(`format-on-save: formatted ${filePath}`, {
+          tool: toolName,
+          delta: `${delta >= 0 ? "+" : ""}${delta} bytes`
+        });
+        return {
+          additionalContext: `
+\u{1F527} format-on-save: applied biome formatting to '${filePath}' after ${toolName}. The file on disk has been reformatted (${delta >= 0 ? "+" : ""}${delta} bytes).`
+        };
+      }
+      state.cleanCount += 1;
+      return;
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "format_on_save_status",
+      description: "Reports format-on-save state: biome availability, and per-session formatted/clean/error counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Code Quality",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          biomeAvailable,
+          timeoutMs: cfg.timeoutMs,
+          counters: {
+            invocations: state.invocationCount,
+            formatted: state.formattedCount,
+            clean: state.cleanCount,
+            errors: state.errorCount
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("format-on-save plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      biomeAvailable
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocationCount,
+      formatted: state.formattedCount,
+      clean: state.cleanCount,
+      errors: state.errorCount
+    };
+    state.invocationCount = 0;
+    state.formattedCount = 0;
+    state.cleanCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    api.log.info("format-on-save: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastResult === null ? `format-on-save: ${state.invocationCount} invocation(s), ${state.formattedCount} formatted` : state.lastResult.changed ? `format-on-save: last formatted ${state.lastResult.path} (${state.lastResult.tool}) at ${state.lastResult.when}` : `format-on-save: last check on ${state.lastResult.path} was already clean`,
+      counters: {
+        invocations: state.invocationCount,
+        formatted: state.formattedCount,
+        clean: state.cleanCount,
+        errors: state.errorCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var format_on_save_default = plugin;
+
+export { format_on_save_default as default };

package/dist/git-autocommit.js

@@ -3,6 +3,9 @@ import { existsSync } from 'fs';
 
 // src/git-autocommit/index.ts
 var API_VERSION = "^0.1.10";
+var commitCount = { value: 0 };
+var lastCommit = { hash: null, at: null };
+var llmGenerated = { value: 0 };
 function runGit(args, cwd) {
   try {
     return execFileSync("git", args, {
@@ -103,6 +106,54 @@ function generateCommitMessage(type, scope, summary, body) {
 ${body}` : "";
   return `${type}${scopePart}: ${summary}${footer}`;
 }
+var VALID_TYPES = [
+  "feat",
+  "fix",
+  "docs",
+  "style",
+  "refactor",
+  "test",
+  "chore",
+  "perf",
+  "ci",
+  "build",
+  "revert"
+];
+async function generateCommitFromDiff(api, stat, diff) {
+  if (!api.llm) return null;
+  try {
+    const result = await api.llm.complete(
+      `Write a Conventional Commits message for this staged git diff. Respond with ONLY a JSON object of the form {"type": string, "scope": string, "summary": string, "body": string}. type is one of: ${VALID_TYPES.join(", ")}. scope is a short area (empty string if unclear). summary is an imperative, lower-case, <=72-char subject with no trailing period. body is an optional short explanation (empty string if not needed). No prose outside the JSON.
+
+Stat:
+${stat}
+
+Diff:
+${diff}`,
+      {
+        system: "You are a precise release engineer writing Conventional Commits. Output only JSON.",
+        maxTokens: 400,
+        responseFormat: "json"
+      }
+    );
+    const parsed = JSON.parse(extractJsonObject(result.text));
+    const type = VALID_TYPES.includes(parsed.type) ? parsed.type : null;
+    const summary = typeof parsed.summary === "string" && parsed.summary.trim() ? parsed.summary.trim() : null;
+    if (!type || !summary) return null;
+    const scope = typeof parsed.scope === "string" && parsed.scope.trim() ? parsed.scope.trim() : void 0;
+    const body = typeof parsed.body === "string" && parsed.body.trim() ? parsed.body.trim() : void 0;
+    return { type, summary, ...scope ? { scope } : {}, ...body ? { body } : {} };
+  } catch {
+    return null;
+  }
+}
+function extractJsonObject(text) {
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
+  const body = fenced?.[1] ?? text;
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  return start >= 0 && end > start ? body.slice(start, end + 1) : body.trim();
+}
 var plugin = {
   name: "git-autocommit",
   version: "0.2.0",
@@ -112,22 +163,40 @@ var plugin = {
   defaultConfig: {
     conventionalCommits: true,
     autoStage: false,
-    defaultType: "feat"
+    defaultType: "feat",
+    useLlm: false
   },
   configSchema: {
     type: "object",
     properties: {
       conventionalCommits: { type: "boolean", default: true },
       autoStage: { type: "boolean", default: false },
-      defaultType: { type: "string", default: "feat" }
+      defaultType: { type: "string", default: "feat" },
+      useLlm: {
+        type: "boolean",
+        default: false,
+        description: 'Auto-generate the commit message with the LLM (api.llm) when the caller supplies neither type nor message. Provider/model follow extensions["git-autocommit"].llm, then the session default.'
+      },
+      llm: {
+        type: "object",
+        description: "Optional { provider, model } override for LLM commit messages."
+      }
     }
   },
   setup(api) {
+    commitCount.value = 0;
+    llmGenerated.value = 0;
+    lastCommit.hash = null;
+    lastCommit.at = null;
     const extConfig = api.config.extensions?.["git-autocommit"];
     const opts = {
       conventionalCommits: extConfig?.["conventionalCommits"] ?? true,
       autoStage: extConfig?.["autoStage"] ?? false,
-      defaultType: extConfig?.["defaultType"] ?? "feat"
+      defaultType: extConfig?.["defaultType"] ?? "feat",
+      // Opt-in: when true, git_autocommit writes the commit message with
+      // the LLM from the staged diff whenever the caller supplies neither
+      // `type` nor `message` (an explicit `generate: true` always asks).
+      useLlm: extConfig?.["useLlm"] ?? false
     };
     api.tools.register({
       name: "git_autocommit",
@@ -142,13 +211,33 @@ var plugin = {
           },
           type: {
             type: "string",
-            enum: ["feat", "fix", "docs", "style", "refactor", "test", "chore", "perf", "ci", "build", "revert"],
+            enum: [
+              "feat",
+              "fix",
+              "docs",
+              "style",
+              "refactor",
+              "test",
+              "chore",
+              "perf",
+              "ci",
+              "build",
+              "revert"
+            ],
             description: "Conventional commit type"
           },
           scope: { type: "string", description: "Commit scope (e.g. auth, api, ui)" },
           message: { type: "string", description: "Commit summary message" },
           body: { type: "string", description: "Optional commit body/description" },
-          dry_run: { type: "boolean", default: false, description: "Show what would be committed without committing" }
+          generate: {
+            type: "boolean",
+            description: "Write the conventional commit message with the LLM (api.llm) from the staged diff. Ignored when no LLM is wired."
+          },
+          dry_run: {
+            type: "boolean",
+            default: false,
+            description: "Show what would be committed without committing"
+          }
         }
       },
       permission: "confirm",
@@ -156,23 +245,14 @@ var plugin = {
       mutating: true,
       async execute(input, _ctx) {
         try {
-          const type = input["type"] ?? opts.defaultType;
-          const scope = input["scope"];
-          const summary = input["message"] ?? "";
-          const body = input["body"];
+          let type = input["type"];
+          let scope = input["scope"];
+          let summary = input["message"] ?? "";
+          let body = input["body"];
           const dryRun = input["dry_run"] ?? false;
-          const validTypes = ["feat", "fix", "docs", "style", "refactor", "test", "chore", "perf", "ci", "build", "revert"];
-          if (!type || !validTypes.includes(type)) {
-            if (dryRun) {
-              return {
-                ok: true,
-                dry_run: true,
-                message: `Would create: ${summary || "update code"}`
-              };
-            }
-            return { ok: false, error: "type is required and must be a valid conventional commit type" };
-          }
-          const msg = generateCommitMessage(type, scope, summary || "update code", body);
+          const explicitAsk = input["generate"] === true;
+          const autoAsk = opts.useLlm && !input["type"] && !input["message"];
+          const wantGenerate = (explicitAsk || autoAsk) && Boolean(api.llm);
           let files;
           const rawFiles = input["files"];
           if (rawFiles !== void 0) {
@@ -185,7 +265,10 @@ var plugin = {
             try {
               stageFiles(files);
             } catch (err) {
-              return { ok: false, error: `Failed to stage files: ${err instanceof Error ? err.message : String(err)}` };
+              return {
+                ok: false,
+                error: `Failed to stage files: ${err instanceof Error ? err.message : String(err)}`
+              };
             }
           }
           let staged = [];
@@ -211,8 +294,51 @@ var plugin = {
             } catch {
             }
           }
+          const { stat, diff: stagedDiff } = getStagedDiff();
+          let generatedByLlm = false;
+          if (wantGenerate && staged.length > 0) {
+            const g = await generateCommitFromDiff(api, stat, stagedDiff);
+            if (g) {
+              type = g.type;
+              if (g.scope) scope = g.scope;
+              summary = g.summary;
+              if (g.body && !body) body = g.body;
+              generatedByLlm = true;
+            }
+          }
+          if (!type) type = opts.defaultType;
+          const validTypes = [
+            "feat",
+            "fix",
+            "docs",
+            "style",
+            "refactor",
+            "test",
+            "chore",
+            "perf",
+            "ci",
+            "build",
+            "revert"
+          ];
+          if (!type || !validTypes.includes(type)) {
+            if (dryRun) {
+              return {
+                ok: true,
+                dry_run: true,
+                message: `Would create: ${summary || "update code"}`
+              };
+            }
+            return {
+              ok: false,
+              error: "type is required and must be a valid conventional commit type"
+            };
+          }
+          const msg = generateCommitMessage(type, scope, summary || "update code", body);
           if (staged.length === 0) {
-            return { ok: false, error: "Nothing staged. Add files with git add or provide files input." };
+            return {
+              ok: false,
+              error: "Nothing staged. Add files with git add or provide files input."
+            };
           }
           const worktreeWarn = simultaneousEditWarning();
           const externalChanges = externalChangesSinceStage();
@@ -223,7 +349,6 @@ var plugin = {
             externalWarning = `\u26A0 External changes detected since staging: ${preview}${suffix}. Another agent may be modifying files concurrently. These unstaged changes will NOT be included in this commit, but they indicate simultaneous edits. Review carefully.`;
           }
           const warning = [worktreeWarn, externalWarning].filter(Boolean).join("\n") || void 0;
-          const { stat, diff: stagedDiff } = getStagedDiff();
           if (dryRun) {
             return {
               ok: true,
@@ -251,9 +376,16 @@ ${stagedDiff}
           try {
             hash = commitWithMessage(msg);
           } catch (err) {
-            return { ok: false, error: `Failed to commit: ${err instanceof Error ? err.message : String(err)}` };
+            return {
+              ok: false,
+              error: `Failed to commit: ${err instanceof Error ? err.message : String(err)}`
+            };
           }
           api.log.info("git-autocommit: created commit", { hash, type, scope });
+          commitCount.value += 1;
+          if (generatedByLlm) llmGenerated.value += 1;
+          lastCommit.hash = String(hash);
+          lastCommit.at = (/* @__PURE__ */ new Date()).toISOString();
           try {
             await api.session.append({
               type: "git-autocommit:commit",
@@ -274,6 +406,7 @@ ${stagedDiff}
             stagedFiles: staged,
             type,
             scope: scope ?? null,
+            generatedByLlm,
             warning: warning ?? void 0,
             diff: `
 ## Staged diff
@@ -285,7 +418,10 @@ ${preCommitDiff}
 \`\`\``
           };
         } catch (err) {
-          return { ok: false, error: `Uncaught error in git_autocommit: ${err instanceof Error ? err.message : String(err)}` };
+          return {
+            ok: false,
+            error: `Uncaught error in git_autocommit: ${err instanceof Error ? err.message : String(err)}`
+          };
         }
       }
     });
@@ -293,6 +429,30 @@ ${preCommitDiff}
       version: "0.2.0",
       conventionalCommits: opts.conventionalCommits
     });
+  },
+  teardown(api) {
+    const finalCount = commitCount.value;
+    const finalHash = lastCommit.hash;
+    const finalLlm = llmGenerated.value;
+    commitCount.value = 0;
+    llmGenerated.value = 0;
+    lastCommit.hash = null;
+    lastCommit.at = null;
+    api.log.info("git-autocommit: teardown complete", {
+      commits: finalCount,
+      llmGenerated: finalLlm,
+      lastHash: finalHash
+    });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: commitCount.value === 0 ? "git-autocommit: no commits yet this session" : `git-autocommit: ${commitCount.value} commit(s) (${llmGenerated.value} LLM-written), last ${String(lastCommit.hash).slice(0, 8)} at ${lastCommit.at}`,
+      commits: commitCount.value,
+      llmGenerated: llmGenerated.value,
+      lastCommitHash: lastCommit.hash,
+      lastCommitAt: lastCommit.at
+    };
   }
 };
 var git_autocommit_default = plugin;

package/dist/import-organizer.d.ts

@@ -0,0 +1,52 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * import-organizer plugin — PostToolUse hook that re-sorts and
+ * de-duplicates imports in a file after every `write` or `edit`.
+ *
+ * This is a heavier, post-write step than `format-on-save` (which only
+ * handles whitespace/formatting). It runs `biome check --write --unsafe`
+ * (or `eslint --fix` as a fallback) on the saved file. The `--unsafe`
+ * flag enables import-organization rules:
+ *  - Sort imports alphabetically within import groups
+ *  - Group by source (builtin, external, internal, relative)
+ *  - Remove unused imports
+ *  - Merge duplicate imports from the same module
+ *
+ * Tools registered:
+ *  - import_organizer_status : Show config + per-session counters
+ *    (invocations / organized / clean / errors + lastResult).
+ *
+ * Hooks registered:
+ *  - PostToolUse with matcher `write|edit`. After the tool completes,
+ *    runs the configured command on the file on disk. The hook reads
+ *    the file fresh from disk (so `edit` tool's post-edit state is
+ *    captured) and detects whether the file changed via byte-count
+ *    comparison. If the file was modified, returns `additionalContext`
+ *    so the LLM sees that imports were reorganized.
+ *
+ * Linter detection is lazy: on the first hook invocation, the plugin
+ * tries `biome` first (since `--unsafe` is required for import
+ * organization), then falls back to `eslint --fix`. If neither
+ * succeeds, the hook logs a one-time warning and becomes a no-op for
+ * the rest of the session. Linter presence is re-checked on every
+ * setup() call so plugin reload can recover if a linter is installed
+ * mid-session.
+ *
+ * Config (`config.extensions['import-organizer']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "command": "npx @biomejs/biome check --write --unsafe",
+ *   "fallbackCommand": "npx eslint --fix",
+ *   "timeoutMs": 10000
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };