@wrongstack/plugins 0.1.0

package/dist/git-autocommit.js

@@ -0,0 +1,305 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+
+// src/git-autocommit/index.ts
+var API_VERSION = "^0.1.10";
+function runGit(args, cwd) {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e4,
+      maxBuffer: 10 * 1024 * 1024
+    }).trim();
+  } catch (err) {
+    const e = err;
+    throw new Error(`git command failed: ${e.message ?? e.stderr ?? String(err)}`);
+  }
+}
+function getChangedFiles(cwd) {
+  const output = runGit(["status", "--porcelain"], cwd);
+  if (!output) return [];
+  return output.split("\n").filter((l) => l.trim()).map((l) => l.slice(3).trim());
+}
+function getStagedFiles(cwd) {
+  const output = runGit(["diff", "--cached", "--name-only"], cwd);
+  return output ? output.split("\n").filter(Boolean) : [];
+}
+function stageFiles(files, cwd) {
+  if (!files || !Array.isArray(files)) return;
+  const existing = files.filter((f) => {
+    try {
+      return existsSync(f);
+    } catch {
+      return false;
+    }
+  });
+  if (existing.length === 0) throw new Error("No files exist to stage");
+  runGit(["add", ...existing], cwd);
+}
+function commitWithMessage(message, cwd) {
+  return runGit(["commit", "-m", message], cwd);
+}
+function getCommitHistory(since, cwd) {
+  const range = `${since}..HEAD` ;
+  const output = runGit(["log", range, "--format=%H %s"], cwd);
+  if (!output) return [];
+  return output.split("\n").filter(Boolean).map((line) => {
+    const spaceIdx = line.indexOf(" ");
+    const hash = line.slice(0, spaceIdx);
+    const message = line.slice(spaceIdx + 1);
+    const typeMatch = message.match(/^(\w+)(!)?:\s/);
+    const type = typeMatch?.[1] ?? "chore";
+    return { hash, message, type };
+  });
+}
+function generateCommitMessage(type, scope, summary, body) {
+  const scopePart = scope ? `(${scope})` : "";
+  const footer = body ? `
+
+${body}` : "";
+  return `${type}${scopePart}: ${summary}${footer}`;
+}
+var plugin = {
+  name: "git-autocommit",
+  version: "0.1.0",
+  description: "AI-powered git staging and conventional commit message generation",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: {
+    conventionalCommits: true,
+    autoStage: false,
+    defaultType: "feat"
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      conventionalCommits: { type: "boolean", default: true },
+      autoStage: { type: "boolean", default: false },
+      defaultType: { type: "string", default: "feat" }
+    }
+  },
+  setup(api) {
+    const cwd = api.config.extensions?.["git-autocommit"];
+    const opts = {
+      conventionalCommits: cwd?.["conventionalCommits"] ?? true,
+      autoStage: cwd?.["autoStage"] ?? false,
+      defaultType: cwd?.["defaultType"] ?? "feat"
+    };
+    api.tools.register({
+      name: "git_autocommit",
+      description: "Stage files and create a git commit with an AI-generated conventional commit message. Pass files to stage specific ones, or leave empty to auto-detect all changed files.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Specific files to stage. If empty, auto-detects all changed files."
+          },
+          type: {
+            type: "string",
+            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" },
+          dryRun: { type: "boolean", default: false, description: "Show what would be committed without committing" }
+        }
+      },
+      permission: "confirm",
+      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"];
+          const dryRun = input["dryRun"] ?? false;
+          const validTypes = ["feat", "fix", "docs", "style", "refactor", "test", "chore", "perf", "ci", "build", "revert"];
+          if (!type || !validTypes.includes(type)) {
+            if (dryRun) {
+              return {
+                ok: true,
+                dryRun: 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);
+          let files;
+          const rawFiles = input["files"];
+          if (rawFiles !== void 0) {
+            if (!Array.isArray(rawFiles)) {
+              return { ok: false, error: "files must be an array of file paths" };
+            }
+            files = rawFiles;
+          }
+          if (files && files.length > 0) {
+            try {
+              stageFiles(files);
+            } catch (err) {
+              return { ok: false, error: `Failed to stage files: ${err instanceof Error ? err.message : String(err)}` };
+            }
+          }
+          let staged = [];
+          try {
+            staged = getStagedFiles();
+          } catch {
+            staged = [];
+          }
+          if (staged.length === 0) {
+            try {
+              const changed = getChangedFiles();
+              if (changed.length > 0) {
+                try {
+                  stageFiles(changed);
+                } catch {
+                }
+                try {
+                  staged = getStagedFiles();
+                } catch {
+                  staged = [];
+                }
+              }
+            } catch {
+            }
+          }
+          if (staged.length === 0) {
+            return { ok: false, error: "Nothing staged. Add files with git add or provide files input." };
+          }
+          let hash = "";
+          try {
+            hash = commitWithMessage(msg);
+          } catch (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 });
+          try {
+            await api.session.append({
+              type: "git-autocommit:commit",
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              hash: String(hash),
+              commitType: type,
+              scope: String(scope ?? ""),
+              files: Array.isArray(staged) ? staged : []
+            });
+          } catch (_err) {
+          }
+          return {
+            ok: true,
+            hash,
+            message: msg,
+            stagedFiles: staged,
+            type,
+            scope: scope ?? null
+          };
+        } catch (err) {
+          return { ok: false, error: `Uncaught error in git_autocommit: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+    });
+    api.tools.register({
+      name: "git_stage",
+      description: "Stage specific files for commit. Shows what would be staged without staging if dryRun is true.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          files: { type: "array", items: { type: "string" }, description: "Files to stage" },
+          dryRun: { type: "boolean", default: false }
+        },
+        required: ["files"]
+      },
+      permission: "confirm",
+      mutating: true,
+      async execute(input) {
+        try {
+          let files;
+          try {
+            files = input["files"] ?? [];
+          } catch {
+            files = [];
+          }
+          const dryRun = input["dryRun"] ?? false;
+          if (!Array.isArray(files) || files.length === 0) {
+            return { ok: false, error: "files must be a non-empty array of file paths" };
+          }
+          if (dryRun) {
+            return { ok: true, dryRun: true, files, message: `Would stage: ${files.join(", ")}` };
+          }
+          try {
+            stageFiles(files);
+          } catch (err) {
+            return { ok: false, error: `Failed to stage files: ${err instanceof Error ? err.message : String(err)}` };
+          }
+          let stillChanged = [];
+          try {
+            stillChanged = getChangedFiles();
+          } catch {
+            stillChanged = [];
+          }
+          return {
+            ok: true,
+            staged: files,
+            stillChanged,
+            message: `Staged ${files.length} file(s). ${stillChanged.length} file(s) still changed.`
+          };
+        } catch (err) {
+          return { ok: false, error: `git_stage error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+    });
+    api.tools.register({
+      name: "git_status_summary",
+      description: "Returns a summary of the current git repository status: changed files, staged files, current branch, and recent commits.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        let branch = "";
+        let changed = [];
+        let staged = [];
+        let aheadBehind = "";
+        const recentCommits = [];
+        try {
+          branch = runGit(["branch", "--show-current"]);
+        } catch {
+        }
+        try {
+          changed = getChangedFiles();
+        } catch {
+        }
+        try {
+          staged = getStagedFiles();
+        } catch {
+        }
+        try {
+          aheadBehind = runGit(["status", "-sb"]).split("\n")[0] ?? "";
+        } catch {
+        }
+        try {
+          recentCommits.push(...getCommitHistory("-3", void 0).map((c) => ({ hash: c.hash.slice(0, 7), message: c.message })));
+        } catch {
+        }
+        return {
+          ok: true,
+          branch,
+          changedFiles: changed,
+          stagedFiles: staged,
+          aheadBehind,
+          recentCommits
+        };
+      }
+    });
+    api.log.info("git-autocommit plugin loaded", {
+      version: "0.1.0",
+      conventionalCommits: opts.conventionalCommits
+    });
+  }
+};
+var git_autocommit_default = plugin;
+
+export { git_autocommit_default as default };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { default as autoDocPlugin } from './auto-doc.js';
+export { default as gitAutocommitPlugin } from './git-autocommit.js';
+export { default as shellCheckPlugin } from './shell-check.js';
+export { default as costTrackerPlugin } from './cost-tracker.js';
+export { default as fileWatcherPlugin } from './file-watcher.js';
+export { default as webSearchPlugin } from './web-search.js';
+export { default as jsonPathPlugin } from './json-path.js';
+export { default as cronPlugin } from './cron.js';
+export { default as templateEnginePlugin } from './template-engine.js';
+export { default as semverBumpPlugin } from './semver-bump.js';
+import '@wrongstack/core';