opencode-commit-guard 1.0.0

package/dist/index.js

@@ -0,0 +1,814 @@
+// @bun
+// src/plugin.ts
+import { Plugin } from "@opencode/plugin";
+
+// src/types.ts
+function isJSONString(value) {
+  return Object.prototype.toString.call(value) === "[object String]";
+}
+function isJSONNumber(value) {
+  return Object.prototype.toString.call(value) === "[object Number]";
+}
+function isJSONBoolean(value) {
+  return Object.prototype.toString.call(value) === "[object Boolean]";
+}
+function isRecord(value) {
+  return value instanceof Object && !Array.isArray(value);
+}
+var defaultConfig = {
+  requireScope: true,
+  allowedScopes: undefined,
+  maxLineLength: 72,
+  requireSignoff: true
+};
+
+// src/config.ts
+function parseConfig(options) {
+  if (options === undefined) {
+    return defaultConfig;
+  }
+  if (!isRecord(options)) {
+    throw new Error("Invalid plugin options; expected an object.");
+  }
+  const rawRequireScope = options["requireScope"];
+  let requireScope = defaultConfig.requireScope;
+  if (rawRequireScope !== undefined) {
+    if (!isJSONBoolean(rawRequireScope)) {
+      throw new Error("Invalid plugin option requireScope; expected a boolean.");
+    }
+    requireScope = rawRequireScope;
+  }
+  const rawAllowedScopes = options["allowedScopes"];
+  let allowedScopes = defaultConfig.allowedScopes;
+  if (rawAllowedScopes !== undefined) {
+    if (!Array.isArray(rawAllowedScopes)) {
+      throw new Error("Invalid plugin option allowedScopes; expected an array of non-empty strings.");
+    }
+    const scopes = [];
+    for (const item of rawAllowedScopes) {
+      if (!isJSONString(item) || item.trim().length === 0) {
+        throw new Error("Invalid plugin option allowedScopes; expected an array of non-empty strings.");
+      }
+      scopes.push(item.trim());
+    }
+    allowedScopes = scopes.length > 0 ? scopes : undefined;
+  }
+  const rawMaxLineLength = options["maxLineLength"];
+  let maxLineLength = defaultConfig.maxLineLength;
+  if (rawMaxLineLength !== undefined) {
+    if (!isJSONNumber(rawMaxLineLength) || !Number.isSafeInteger(rawMaxLineLength) || rawMaxLineLength < 0) {
+      throw new Error("Invalid plugin option maxLineLength; expected an integer greater than or equal to 0.");
+    }
+    maxLineLength = rawMaxLineLength;
+  }
+  const rawRequireSignoff = options["requireSignoff"];
+  let requireSignoff = defaultConfig.requireSignoff;
+  if (rawRequireSignoff !== undefined) {
+    if (!isJSONBoolean(rawRequireSignoff)) {
+      throw new Error("Invalid plugin option requireSignoff; expected a boolean.");
+    }
+    requireSignoff = rawRequireSignoff;
+  }
+  return {
+    requireScope,
+    allowedScopes,
+    maxLineLength,
+    requireSignoff
+  };
+}
+
+// src/shell.ts
+var gitGlobalOptionsWithArg = new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--super-prefix"
+]);
+var commandPrefixes = new Set([
+  "!",
+  "do",
+  "elif",
+  "else",
+  "if",
+  "then",
+  "time",
+  "until",
+  "while"
+]);
+var commitLongOptionsWithArg = new Set([
+  "--author",
+  "--cleanup",
+  "--date",
+  "--fixup",
+  "--pathspec-from-file",
+  "--reedit-message",
+  "--reuse-message",
+  "--squash",
+  "--template",
+  "--trailer"
+]);
+function isWordSeparator(character) {
+  return character === " " || character === "\t" || character === "\r" || character === `
+` || character === ";" || character === "&" || character === "|" || character === "(" || character === ")" || character === "{" || character === "}";
+}
+function consumeCommandSubstitution(command, start) {
+  let depth = 1;
+  let quote;
+  let i = start + 2;
+  let atWordStart = true;
+  while (i < command.length) {
+    const character = command[i];
+    if (character === undefined)
+      break;
+    if (quote === "'") {
+      if (character === "'")
+        quote = undefined;
+      i++;
+      continue;
+    }
+    if (quote === '"') {
+      if (character === "\\") {
+        i += i + 1 < command.length ? 2 : 1;
+      } else if (character === '"') {
+        quote = undefined;
+        i++;
+      } else if (character === "$" && command[i + 1] === "(") {
+        i = consumeCommandSubstitution(command, i).end;
+      } else {
+        i++;
+      }
+      continue;
+    }
+    if (character === "\\") {
+      if (command[i + 1] !== `
+`)
+        atWordStart = false;
+      i += i + 1 < command.length ? 2 : 1;
+      continue;
+    }
+    if (character === "'") {
+      quote = "'";
+      atWordStart = false;
+      i++;
+      continue;
+    }
+    if (character === '"') {
+      quote = '"';
+      atWordStart = false;
+      i++;
+      continue;
+    }
+    if (character === "#" && atWordStart) {
+      while (i < command.length && command[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (character === "$" && command[i + 1] === "(") {
+      i = consumeCommandSubstitution(command, i).end;
+      atWordStart = false;
+      continue;
+    }
+    if (character === "(") {
+      depth++;
+      i++;
+      atWordStart = true;
+      continue;
+    }
+    if (character === ")") {
+      depth--;
+      if (depth === 0) {
+        return { content: command.slice(start + 2, i), end: i + 1 };
+      }
+      atWordStart = true;
+    }
+    if (isWordSeparator(character))
+      atWordStart = true;
+    else
+      atWordStart = false;
+    i++;
+  }
+  return { content: command.slice(start + 2), end: command.length };
+}
+function pushWord(tokens, value, substitutions) {
+  if (substitutions.length > 0) {
+    tokens.push({ type: "word", value, substitutions });
+  } else {
+    tokens.push({ type: "word", value });
+  }
+}
+function tokenizeShell(command) {
+  const tokens = [];
+  let i = 0;
+  while (i < command.length) {
+    const character = command[i];
+    if (character === undefined)
+      break;
+    if (character === " " || character === "\t" || character === "\r") {
+      i++;
+      continue;
+    }
+    if (character === "\\" && command[i + 1] === `
+`) {
+      i += 2;
+      continue;
+    }
+    if (character === "#") {
+      while (i < command.length && command[i] !== `
+`)
+        i++;
+      continue;
+    }
+    const twoCharacters = command.slice(i, i + 2);
+    if (twoCharacters === "&&" || twoCharacters === "||" || twoCharacters === "|&" || twoCharacters === ";;") {
+      tokens.push({ type: "operator", value: twoCharacters });
+      i += 2;
+      continue;
+    }
+    if (character === "|" || character === ";" || character === "&" || character === `
+` || character === "(" || character === ")" || character === "{" || character === "}") {
+      tokens.push({ type: "operator", value: character });
+      i++;
+      continue;
+    }
+    const redirectMatch = command.slice(i).match(/^(\d+)?(<<<|>>|<<|>&|<&|>\||>|<)(?:-|\d+)?/);
+    if (redirectMatch !== null && redirectMatch[0] !== undefined) {
+      tokens.push({ type: "redirect", value: redirectMatch[0] });
+      i += redirectMatch[0].length;
+      continue;
+    }
+    let value = "";
+    const substitutions = [];
+    while (i < command.length) {
+      const current = command[i];
+      if (current === undefined || isWordSeparator(current))
+        break;
+      if (current === "\\" && command[i + 1] === `
+`) {
+        i += 2;
+        continue;
+      }
+      if (current === "\\") {
+        if (i + 1 < command.length) {
+          value += command[i + 1];
+          i += 2;
+        } else {
+          value += "\\";
+          i++;
+        }
+        continue;
+      }
+      if (current === "$" && command[i + 1] === "'") {
+        i += 2;
+        while (i < command.length) {
+          const ansiCharacter = command[i];
+          if (ansiCharacter === undefined)
+            break;
+          if (ansiCharacter === "'") {
+            i++;
+            break;
+          }
+          if (ansiCharacter === "\\" && i + 1 < command.length) {
+            const escaped = command[i + 1];
+            if (escaped === "n")
+              value += `
+`;
+            else if (escaped === "t")
+              value += "\t";
+            else if (escaped === "r")
+              value += "\r";
+            else if (escaped === "\\")
+              value += "\\";
+            else if (escaped === "'")
+              value += "'";
+            else if (escaped === '"')
+              value += '"';
+            else
+              value += escaped;
+            i += 2;
+          } else {
+            value += ansiCharacter;
+            i++;
+          }
+        }
+        continue;
+      }
+      if (current === "'") {
+        i++;
+        while (i < command.length && command[i] !== "'") {
+          value += command[i];
+          i++;
+        }
+        if (command[i] === "'")
+          i++;
+        continue;
+      }
+      if (current === '"') {
+        i++;
+        while (i < command.length && command[i] !== '"') {
+          const quotedCharacter = command[i];
+          if (quotedCharacter === undefined)
+            break;
+          if (quotedCharacter === "\\" && i + 1 < command.length) {
+            const escaped = command[i + 1];
+            if (escaped === `
+`) {
+              i += 2;
+            } else if (escaped === '"' || escaped === "\\" || escaped === "$" || escaped === "`") {
+              value += escaped;
+              i += 2;
+            } else {
+              value += `\\${escaped}`;
+              i += 2;
+            }
+          } else if (quotedCharacter === "$" && command[i + 1] === "(") {
+            const substitution = consumeCommandSubstitution(command, i);
+            value += command.slice(i, substitution.end);
+            substitutions.push(substitution.content);
+            i = substitution.end;
+          } else {
+            value += quotedCharacter;
+            i++;
+          }
+        }
+        if (command[i] === '"')
+          i++;
+        continue;
+      }
+      if (current === "$" && command[i + 1] === "(") {
+        const substitution = consumeCommandSubstitution(command, i);
+        value += command.slice(i, substitution.end);
+        substitutions.push(substitution.content);
+        i = substitution.end;
+        continue;
+      }
+      const nextRedirect = command.slice(i).match(/^(\d+)?(<<<|>>|<<|>&|<&|>\||>|<)(?:-|\d+)?/);
+      if (nextRedirect !== null)
+        break;
+      value += current;
+      i++;
+    }
+    pushWord(tokens, value, substitutions);
+  }
+  return tokens;
+}
+function splitSimpleCommands(tokens) {
+  const commands = [];
+  let current = [];
+  for (const token of tokens) {
+    if (token.type === "operator") {
+      if (current.length > 0)
+        commands.push(current);
+      current = [];
+    } else {
+      current.push(token);
+    }
+  }
+  if (current.length > 0)
+    commands.push(current);
+  return commands;
+}
+function extractCommandWords(tokens) {
+  const words = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === undefined)
+      break;
+    if (token.type === "redirect") {
+      if (!token.value.includes("&") && tokens[i + 1]?.type === "word")
+        i += 2;
+      else
+        i++;
+      continue;
+    }
+    if (token.type === "word") {
+      words.push(token.value);
+    }
+    i++;
+  }
+  return words;
+}
+function isAssignment(word) {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*=/.test(word);
+}
+function skipAssignments(words, start) {
+  let index = start;
+  while (words[index] !== undefined && isAssignment(words[index]))
+    index++;
+  return index;
+}
+function findCommandStart(words) {
+  let index = skipAssignments(words, 0);
+  const directoryChanges = [];
+  while (index < words.length) {
+    const word = words[index];
+    if (word !== undefined && commandPrefixes.has(word)) {
+      index = skipAssignments(words, index + 1);
+      continue;
+    }
+    if (word === "env") {
+      index++;
+      while (index < words.length) {
+        const argument = words[index];
+        if (argument === undefined)
+          break;
+        if (argument === "--") {
+          index++;
+          break;
+        }
+        if (argument === "-u" || argument === "--unset") {
+          index += 2;
+        } else if (argument === "-C" || argument === "--chdir") {
+          const directory = words[index + 1];
+          if (directory !== undefined) {
+            directoryChanges.push(directory);
+          }
+          index += 2;
+        } else if (argument.startsWith("--chdir=")) {
+          directoryChanges.push(argument.slice("--chdir=".length));
+          index++;
+        } else if (/^-C.+/.test(argument)) {
+          directoryChanges.push(argument.slice(2));
+          index++;
+        } else if (argument.startsWith("--unset=") || /^-u.+/.test(argument)) {
+          index++;
+        } else if (argument.startsWith("-")) {
+          index++;
+        } else if (isAssignment(argument)) {
+          index++;
+        } else {
+          break;
+        }
+      }
+      index = skipAssignments(words, index);
+      continue;
+    }
+    if (word === "exec") {
+      index++;
+      while (index < words.length) {
+        const argument = words[index];
+        if (argument === "--") {
+          index++;
+          break;
+        }
+        if (argument === "-a")
+          index += 2;
+        else if (argument !== undefined && argument.startsWith("-"))
+          index++;
+        else
+          break;
+      }
+      index = skipAssignments(words, index);
+      continue;
+    }
+    if (word === "command" || word === "nohup" || word === "builtin") {
+      index++;
+      while (words[index]?.startsWith("-"))
+        index++;
+      index = skipAssignments(words, index);
+      continue;
+    }
+    break;
+  }
+  return { index, directoryChanges };
+}
+function extractInvocation(words, commandStart) {
+  let wordIndex = commandStart.index;
+  const executable = words[wordIndex];
+  if (executable === undefined || executable !== "git" && !executable.endsWith("/git"))
+    return;
+  wordIndex++;
+  const directoryChanges = [...commandStart.directoryChanges];
+  let subcommand;
+  while (wordIndex < words.length) {
+    const argument = words[wordIndex];
+    if (argument === undefined)
+      break;
+    if (argument === "--") {
+      subcommand = words[wordIndex + 1];
+      wordIndex += 2;
+      break;
+    }
+    if (gitGlobalOptionsWithArg.has(argument)) {
+      const optionValue = words[wordIndex + 1];
+      if (argument === "-C" && optionValue !== undefined) {
+        directoryChanges.push(optionValue);
+      }
+      wordIndex += 2;
+      continue;
+    }
+    if (argument.startsWith("--git-dir=") || argument.startsWith("--work-tree=") || argument.startsWith("--namespace=") || argument.startsWith("--exec-path=") || argument.startsWith("--super-prefix=") || argument.startsWith("-c")) {
+      wordIndex++;
+      continue;
+    }
+    if (argument.startsWith("-C")) {
+      directoryChanges.push(argument.slice(2));
+      wordIndex++;
+      continue;
+    }
+    if (argument.startsWith("-")) {
+      wordIndex++;
+      continue;
+    }
+    subcommand = argument;
+    wordIndex++;
+    break;
+  }
+  if (subcommand !== "commit")
+    return;
+  const messages = [];
+  const filePaths = [];
+  let hasSignoffFlag = false;
+  let isAmend = false;
+  let hasNoEdit = false;
+  let isHelp = false;
+  const collectMessage = (word) => {
+    if (word === undefined)
+      return;
+    messages.push(word);
+  };
+  const collectFile = (word) => {
+    if (word === undefined)
+      return;
+    filePaths.push(word);
+  };
+  for (let index = wordIndex;index < words.length; index++) {
+    const argument = words[index];
+    if (argument === undefined)
+      break;
+    if (argument === "--")
+      break;
+    if (argument === "-h" || argument === "--help") {
+      isHelp = true;
+    } else if (argument === "--amend") {
+      isAmend = true;
+    } else if (argument === "--no-edit") {
+      hasNoEdit = true;
+    } else if (argument === "--edit") {
+      hasNoEdit = false;
+    } else if (argument === "-s" || argument === "--signoff") {
+      hasSignoffFlag = true;
+    } else if (argument === "--no-signoff") {
+      hasSignoffFlag = false;
+    } else if (argument === "-m" || argument === "--message") {
+      index++;
+      collectMessage(words[index]);
+    } else if (argument.startsWith("--message=")) {
+      collectMessage(argument.slice("--message=".length));
+    } else if (argument === "-F" || argument === "--file") {
+      index++;
+      collectFile(words[index]);
+    } else if (argument.startsWith("--file=")) {
+      collectFile(argument.slice("--file=".length));
+    } else if (commitLongOptionsWithArg.has(argument)) {
+      index++;
+    } else if (argument.startsWith("-") && !argument.startsWith("--") && argument.length > 1) {
+      for (let characterIndex = 1;characterIndex < argument.length; characterIndex++) {
+        const option = argument[characterIndex];
+        if (option === "s") {
+          hasSignoffFlag = true;
+        } else if (option === "h") {
+          isHelp = true;
+        } else if (option === "e") {
+          hasNoEdit = false;
+        } else if (option === "m" || option === "F") {
+          const attached = argument.slice(characterIndex + 1);
+          const input = attached.length > 0 ? attached : words[++index];
+          if (option === "m")
+            collectMessage(input);
+          else
+            collectFile(input);
+          break;
+        } else if (option === "S") {
+          break;
+        } else if (option === "u") {
+          break;
+        } else if (option === "c" || option === "C" || option === "t") {
+          if (argument.slice(characterIndex + 1).length === 0)
+            index++;
+          break;
+        }
+      }
+    }
+  }
+  return {
+    messages,
+    filePaths,
+    hasSignoffFlag,
+    isAmend,
+    hasNoEdit,
+    isHelp,
+    directoryChanges
+  };
+}
+function extractGitCommits(command) {
+  const tokens = tokenizeShell(command);
+  const invocations = [];
+  for (const commandTokens of splitSimpleCommands(tokens)) {
+    const words = extractCommandWords(commandTokens);
+    const commandStart = findCommandStart(words);
+    const invocation = extractInvocation(words, commandStart);
+    if (invocation !== undefined)
+      invocations.push(invocation);
+  }
+  for (const token of tokens) {
+    for (const substitution of token.substitutions ?? []) {
+      invocations.push(...extractGitCommits(substitution));
+    }
+  }
+  return invocations;
+}
+
+// src/validator.ts
+import { closeSync, constants, existsSync, fstatSync, openSync, readSync, statSync } from "fs";
+import { resolve } from "path";
+var scopePattern = /^([a-zA-Z0-9_\-./]+(?:\([a-zA-Z0-9_\-./]+\))?):\s+(.+)$/;
+var signoffPattern = /^\s*Signed-off-by:\s+[^<>\r\n]+\s+<[^<>\r\n@]+@[^<>\r\n@]+>\s*$/i;
+var maxMessageFileSize = 64 * 1024;
+function hasSignoffTrailer(lines) {
+  const subjectIndex = lines.findIndex((line) => line.trim().length > 0);
+  return subjectIndex >= 0 && lines.slice(subjectIndex + 1).some((line) => signoffPattern.test(line));
+}
+function validateAllowedScope(rawScope, allowedScopes) {
+  const parenthesizedScope = rawScope.match(/^([^(]+)\(([^)]+)\)$/);
+  const conventionalType = parenthesizedScope?.[1];
+  const innerScope = parenthesizedScope?.[2];
+  const isAllowed = allowedScopes.includes(rawScope) || innerScope !== undefined && allowedScopes.includes(innerScope) || conventionalType !== undefined && allowedScopes.includes(conventionalType);
+  if (isAllowed)
+    return;
+  return `Scope "${rawScope}" is not in the allowed scopes list. Allowed scopes: ${allowedScopes.join(", ")}.`;
+}
+function createCommitGuardError(violations, originalCommand) {
+  const header = "[commit-guard] Git commit rejected: commit message format rules violated.";
+  const violationText = violations.map((v, i) => `${i + 1}. ${v}`).join(`
+
+`);
+  const examples = [
+    "Example of a correctly formatted git commit:",
+    '  git commit -s -m "kernel: add support for foo"',
+    '  git commit -s -m "releasetools: fix ota generation" -m "Detailed explanation of why this fix is needed."',
+    '  git commit -m "feat(parser): add subshell support" -m "Signed-off-by: Developer <dev@example.com>"'
+  ].join(`
+`);
+  return new Error(`${header}
+
+Violations:
+${violationText}
+
+${examples}
+
+Command attempted:
+  ${originalCommand}`);
+}
+function validateGitCommits(invocations, config, originalCommand, workingDirectory) {
+  const allViolations = [];
+  for (const invocation of invocations) {
+    if (invocation.isHelp) {
+      continue;
+    }
+    if (invocation.isAmend && invocation.hasNoEdit === true && invocation.messages.length === 0 && invocation.filePaths.length === 0) {
+      continue;
+    }
+    const collectedMessages = [...invocation.messages];
+    let messageDirectory = workingDirectory ?? process.cwd();
+    for (const directoryChange of invocation.directoryChanges ?? []) {
+      messageDirectory = resolve(messageDirectory, directoryChange);
+    }
+    const filePath = invocation.filePaths.at(-1);
+    if (filePath !== undefined) {
+      if (filePath === "-") {
+        allViolations.push("Cannot validate a commit message read from standard input. Use -m or a regular message file.");
+        continue;
+      }
+      const fullPath = resolve(messageDirectory, filePath);
+      if (!existsSync(fullPath)) {
+        allViolations.push(`Commit message file "${filePath}" does not exist.`);
+        continue;
+      }
+      try {
+        const fileInfo = statSync(fullPath);
+        if (!fileInfo.isFile()) {
+          allViolations.push(`Commit message path "${filePath}" is not a regular file.`);
+          continue;
+        }
+        if (fileInfo.size > maxMessageFileSize) {
+          allViolations.push(`Commit message file "${filePath}" exceeds the 64 KB size limit.`);
+          continue;
+        }
+        const descriptor = openSync(fullPath, constants.O_RDONLY | constants.O_NONBLOCK);
+        try {
+          const openedFileInfo = fstatSync(descriptor);
+          if (!openedFileInfo.isFile()) {
+            allViolations.push(`Commit message path "${filePath}" is not a regular file.`);
+            continue;
+          }
+          const fileContent = Buffer.alloc(maxMessageFileSize + 1);
+          const bytesRead = readSync(descriptor, fileContent, 0, fileContent.length, 0);
+          if (bytesRead > maxMessageFileSize) {
+            allViolations.push(`Commit message file "${filePath}" exceeds the 64 KB size limit.`);
+            continue;
+          }
+          collectedMessages.push(fileContent.toString("utf-8", 0, bytesRead));
+        } finally {
+          closeSync(descriptor);
+        }
+      } catch (readError) {
+        const errorDetail = readError instanceof Error ? readError.message : "Cannot read file";
+        allViolations.push(`Failed to read commit message file "${filePath}": ${errorDetail}`);
+      }
+    }
+    if (collectedMessages.length === 0) {
+      if (invocation.filePaths.length === 0) {
+        allViolations.push('No commit message provided. Commits in OpenCode must provide a commit message via -m "<scope>: <subject>" or -F <file>.');
+      }
+      continue;
+    }
+    const fullMessage = collectedMessages.join(`
+
+`);
+    const lines = fullMessage.split(/\r?\n/);
+    const firstLine = lines[0] ?? "";
+    const subjectLine = firstLine.trim();
+    const scopeMatch = subjectLine.match(scopePattern);
+    if (scopeMatch?.[1] !== undefined && config.allowedScopes !== undefined && config.allowedScopes.length > 0) {
+      const scopeViolation = validateAllowedScope(scopeMatch[1], config.allowedScopes);
+      if (scopeViolation !== undefined)
+        allViolations.push(scopeViolation);
+    }
+    if (config.requireScope) {
+      if (subjectLine.length === 0) {
+        allViolations.push('Subject line is empty. The commit message must begin with "<scope>: <subject>".');
+      } else if (scopeMatch === null) {
+        if (/^:\s*/.test(subjectLine)) {
+          allViolations.push(`Missing scope before colon in subject line "${subjectLine}". Expected format: "<scope>: <subject>".`);
+        } else if (/^[^:]+:\S/.test(subjectLine)) {
+          allViolations.push(`Missing space after colon in subject line "${subjectLine}". Expected format: "<scope>: <subject>".`);
+        } else if (/^[^:]+:\s*$/.test(subjectLine)) {
+          allViolations.push(`Subject text after colon is empty in "${subjectLine}". Expected format: "<scope>: <subject>".`);
+        } else {
+          allViolations.push(`Missing scope in subject line "${subjectLine}". First line must follow "<scope>: <subject>" format (e.g., "kernel: add support for foo" or "feat(parser): add subshell support").`);
+        }
+      }
+    }
+    if (config.maxLineLength > 0) {
+      const overlongLines = [];
+      for (let i = 0;i < lines.length; i++) {
+        const line = lines[i];
+        if (line !== undefined && line.length > config.maxLineLength) {
+          overlongLines.push({ lineNumber: i + 1, length: line.length, text: line });
+        }
+      }
+      if (overlongLines.length > 0) {
+        const details = overlongLines.map((l) => `  - Line ${l.lineNumber} (${l.length} chars, max ${config.maxLineLength}): "${l.text}"`).join(`
+`);
+        allViolations.push(`Commit message exceeds maximum line length of ${config.maxLineLength} characters:
+${details}`);
+      }
+    }
+    if (config.requireSignoff) {
+      const hasSignoff = invocation.hasSignoffFlag || hasSignoffTrailer(lines);
+      if (!hasSignoff) {
+        allViolations.push("Missing commit signoff. Commit must either include the '-s' or '--signoff' flag, or contain a valid 'Signed-off-by: Name <email>' trailer in the message body.");
+      }
+    }
+  }
+  if (allViolations.length > 0) {
+    throw createCommitGuardError(allViolations, originalCommand);
+  }
+}
+
+// src/plugin.ts
+var plugin = Plugin.define({
+  id: "opencode-commit-guard",
+  setup: async (ctx) => {
+    const config = parseConfig(ctx.options);
+    const sessionDirectory = ctx.location.directory;
+    await ctx.tool.hook("execute.before", async (event) => {
+      if (event.tool !== "shell" && event.tool !== "bash") {
+        return;
+      }
+      const rawInput = event.input;
+      if (!isRecord(rawInput)) {
+        return;
+      }
+      const command = rawInput["command"];
+      if (!isJSONString(command)) {
+        return;
+      }
+      const invocations = extractGitCommits(command);
+      if (invocations.length === 0) {
+        return;
+      }
+      const workdir = rawInput["workdir"];
+      validateGitCommits(invocations, config, command, isJSONString(workdir) ? workdir : sessionDirectory);
+    });
+  }
+});
+var plugin_default = plugin;
+export {
+  plugin_default as default
+};