@wipcomputer/wip-license-guard 1.0.0

package/LICENSE

@@ -0,0 +1,52 @@
+Dual License: MIT + AGPLv3
+
+Copyright (c) 2026 WIP Computer, Inc.
+
+
+1. MIT License (local and personal use)
+---------------------------------------
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+2. GNU Affero General Public License v3.0 (commercial and cloud use)
+--------------------------------------------------------------------
+
+If you run this software as part of a hosted service, cloud platform,
+marketplace listing, or any network-accessible offering for commercial
+purposes, the AGPLv3 terms apply. You must either:
+
+  a) Release your complete source code under AGPLv3, or
+  b) Obtain a commercial license.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+AGPLv3 for personal use is free. Commercial licenses available.

package/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: wip-license-guard
+description: License compliance for your own repos. Ensures correct copyright headers, dual-license blocks, and LICENSE files across all source files.
+license: MIT
+interface: [cli, skill]
+metadata:
+  display-name: "License Guard"
+  version: "1.0.0"
+  homepage: "https://github.com/wipcomputer/wip-ai-devops-toolbox"
+  author: "Parker Todd Brooks"
+  category: dev-tools
+  capabilities:
+    - copyright-enforcement
+    - license-compliance
+    - license-file-check
+  requires:
+    bins: [node, git]
+  openclaw:
+    requires:
+      bins: [node, git]
+    install:
+      - id: node
+        kind: node
+        package: "@wipcomputer/wip-license-guard"
+        bins: [wip-license-guard]
+        label: "Install via npm"
+    emoji: "📜"
+---
+
+# wip-license-guard
+
+License compliance for your own repos. Scans source files for correct copyright headers, verifies dual-license blocks (MIT + AGPL), and checks LICENSE files.
+
+## When to Use This Skill
+
+- Before a release, to verify all files have correct license headers
+- After adding new source files to a repo
+- To enforce the MIT/AGPL dual-license pattern
+
+## CLI
+
+```bash
+wip-license-guard /path/to/repo          # scan and report
+wip-license-guard /path/to/repo --fix    # auto-fix missing headers
+```

package/cli.mjs

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+// wip-license-guard
+// License compliance for your own repos.
+// Ensures correct copyright, dual-license blocks, and LICENSE files.
+
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { generateLicense, generateReadmeBlock } from './core.mjs';
+
+const args = process.argv.slice(2);
+const HELP_FLAGS = ['--help', '-h', 'help'];
+const command = HELP_FLAGS.some(f => args.includes(f)) ? 'help' : (args.find(a => !a.startsWith('--')) || 'check');
+const target = args.find((a, i) => i > 0 && !a.startsWith('--')) || '.';
+const FIX = args.includes('--fix');
+const QUIET = args.includes('--quiet');
+const FROM_STANDARD = args.includes('--from-standard');
+
+function log(msg) { if (!QUIET) console.log(msg); }
+function ok(msg) { if (!QUIET) console.log(`  \u2713 ${msg}`); }
+function warn(msg) { console.log(`  \u2717 ${msg}`); }
+
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// WIP Computer standard defaults
+const WIP_STANDARD = {
+  copyright: 'WIP Computer, Inc.',
+  license: 'MIT+AGPL',
+  year: String(new Date().getFullYear()),
+  attribution: 'Built by Parker Todd Brooks, Lēsa (OpenClaw, Claude Opus 4.6), Claude Code (Claude Opus 4.6).',
+};
+
+function generateCLA() {
+  return `###### WIP Computer
+
+# Contributor License Agreement
+
+By submitting a pull request to this repository, you agree to the following:
+
+1. **You grant WIP Computer, Inc. a perpetual, worldwide, non-exclusive, royalty-free, irrevocable license** to use, reproduce, modify, distribute, sublicense, and otherwise exploit your contribution under any license, including commercial licenses.
+
+2. **You retain copyright** to your contribution. This agreement does not transfer ownership. You can use your own code however you want.
+
+3. **You confirm** that your contribution is your original work, or that you have the right to submit it under these terms.
+
+4. **You understand** that your contribution may be used in both open source and commercial versions of this software.
+
+This is standard open source governance. Apache, Google, Meta, and Anthropic all use similar agreements. The goal is simple: keep the tools free for everyone while allowing WIP Computer, Inc. to offer commercial licenses to companies that need them.
+
+Using these tools to build your own software is always free. This agreement only matters if WIP Computer, Inc. needs to relicense the codebase commercially.
+
+If you have questions, open an issue or reach out.
+`;
+}
+
+async function init(repoPath) {
+  const configPath = join(repoPath, '.license-guard.json');
+
+  // --from-standard: apply WIP Computer defaults without prompting
+  if (FROM_STANDARD) {
+    log('\n  wip-license-guard init --from-standard\n');
+
+    const config = { ...WIP_STANDARD, created: new Date().toISOString() };
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    ok(`Config saved to .license-guard.json`);
+
+    const licensePath = join(repoPath, 'LICENSE');
+    writeFileSync(licensePath, generateLicense(config));
+    ok(`LICENSE file generated (dual MIT+AGPLv3)`);
+
+    const claPath = join(repoPath, 'CLA.md');
+    if (!existsSync(claPath)) {
+      writeFileSync(claPath, generateCLA());
+      ok(`CLA.md generated`);
+    } else {
+      ok(`CLA.md already exists`);
+    }
+
+    log(`\n  Standard: ${config.copyright}, ${config.license}, ${config.year}`);
+    log(`  Done. Run \`wip-license-guard check\` to audit.\n`);
+    return config;
+  }
+
+  if (existsSync(configPath)) {
+    const existing = JSON.parse(readFileSync(configPath, 'utf8'));
+    log(`\nLicense guard already configured:`);
+    log(`  Copyright: ${existing.copyright}`);
+    log(`  License: ${existing.license}`);
+    log(`  Year: ${existing.year}`);
+    const update = await ask('\nUpdate? (y/N) ');
+    if (update.toLowerCase() !== 'y') {
+      log('Keeping existing config.');
+      return existing;
+    }
+  }
+
+  log('\n  wip-license-guard init\n');
+
+  const copyright = await ask('  Copyright holder (e.g. WIP Computer, Inc.): ');
+  if (!copyright) {
+    console.error('Copyright holder is required.');
+    process.exit(1);
+  }
+
+  log('\n  License types:');
+  log('    1. MIT only');
+  log('    2. AGPLv3 only');
+  log('    3. MIT + AGPLv3 dual-license (recommended for WIP repos)');
+  const licenseChoice = await ask('\n  Choose (1/2/3): ');
+
+  const licenseMap = { '1': 'MIT', '2': 'AGPL-3.0', '3': 'MIT+AGPL' };
+  const license = licenseMap[licenseChoice] || 'MIT+AGPL';
+
+  const currentYear = new Date().getFullYear();
+  const yearInput = await ask(`  Copyright year (${currentYear}): `);
+  const year = yearInput || String(currentYear);
+
+  const attribution = await ask('  Attribution (e.g. Built by Parker Todd Brooks, ...): ');
+
+  const config = { copyright, license, year, attribution, created: new Date().toISOString() };
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  ok(`Config saved to .license-guard.json`);
+
+  const licensePath = join(repoPath, 'LICENSE');
+  const licenseText = generateLicense(config);
+  writeFileSync(licensePath, licenseText);
+  ok(`LICENSE file generated`);
+
+  // Generate CLA.md if it doesn't exist
+  const claPath = join(repoPath, 'CLA.md');
+  if (!existsSync(claPath)) {
+    writeFileSync(claPath, generateCLA());
+    ok(`CLA.md generated`);
+  }
+
+  log(`\nDone. Run \`wip-license-guard check\` to audit.`);
+  return config;
+}
+
+async function check(repoPath) {
+  const configPath = join(repoPath, '.license-guard.json');
+
+  if (!existsSync(configPath)) {
+    log('\n  No .license-guard.json found.');
+    const doInit = await ask('  Initialize license guard? (Y/n) ');
+    if (doInit.toLowerCase() !== 'n') {
+      await init(repoPath);
+      return 0;
+    }
+    process.exit(1);
+  }
+
+  const config = JSON.parse(readFileSync(configPath, 'utf8'));
+  let issues = 0;
+
+  log(`\n  wip-license-guard check\n`);
+  log(`  Copyright: ${config.copyright}`);
+  log(`  License: ${config.license}\n`);
+
+  // Check LICENSE file
+  const licensePath = join(repoPath, 'LICENSE');
+  if (!existsSync(licensePath)) {
+    warn('LICENSE file missing');
+    issues++;
+    if (FIX) {
+      writeFileSync(licensePath, generateLicense(config));
+      ok('LICENSE file created (--fix)');
+      issues--;
+    }
+  } else {
+    const licenseText = readFileSync(licensePath, 'utf8');
+
+    if (!licenseText.includes(config.copyright)) {
+      warn(`LICENSE copyright does not match "${config.copyright}"`);
+      issues++;
+      if (FIX) {
+        writeFileSync(licensePath, generateLicense(config));
+        ok('LICENSE file updated (--fix)');
+        issues--;
+      }
+    } else {
+      ok('LICENSE copyright correct');
+    }
+
+    if (config.license === 'MIT+AGPL') {
+      if (!licenseText.includes('AGPL') && !licenseText.includes('GNU Affero')) {
+        warn('LICENSE file is MIT-only but config says MIT+AGPL');
+        issues++;
+        if (FIX) {
+          writeFileSync(licensePath, generateLicense(config));
+          ok('LICENSE file updated to dual-license (--fix)');
+          issues--;
+        }
+      } else {
+        ok('LICENSE includes AGPLv3 terms');
+      }
+    }
+  }
+
+  // Check CLA.md
+  const claPath = join(repoPath, 'CLA.md');
+  if (!existsSync(claPath)) {
+    warn('CLA.md missing');
+    issues++;
+    if (FIX) {
+      writeFileSync(claPath, generateCLA());
+      ok('CLA.md created (--fix)');
+      issues--;
+    }
+  } else {
+    ok('CLA.md exists');
+  }
+
+  // Check README (license + structure standard)
+  const readmePath = join(repoPath, 'README.md');
+  if (existsSync(readmePath)) {
+    const readme = readFileSync(readmePath, 'utf8');
+
+    // License checks
+    if (!readme.includes('## License')) {
+      warn('README.md missing ## License section');
+      issues++;
+    } else {
+      ok('README.md has License section');
+    }
+
+    if (config.license === 'MIT+AGPL' && !readme.includes('AGPL')) {
+      warn('README.md License section missing AGPL reference');
+      issues++;
+    } else if (config.license === 'MIT+AGPL') {
+      ok('README.md references AGPL');
+    }
+
+    // README structure standard checks
+    if (!readme.match(/^#\s+\S/m)) {
+      warn('README.md missing # title');
+      issues++;
+    } else {
+      ok('README.md has title');
+    }
+
+    if (config.attribution && !readme.includes(config.attribution.split(',')[0])) {
+      warn('README.md missing attribution');
+      issues++;
+    } else if (config.attribution) {
+      ok('README.md has attribution');
+    }
+
+    // Warn if README contains content that belongs in TECHNICAL.md
+    const technicalPatterns = [
+      /## (Architecture|API|Config|Configuration|Build|Development Setup|Quick Start)/i,
+      /```json\s*\n\s*\{[\s\S]*?"command"/,  // MCP config blocks
+      /npm install -g /,  // install commands belong in TECHNICAL.md
+    ];
+    for (const pattern of technicalPatterns) {
+      if (pattern.test(readme)) {
+        warn('README.md contains technical content (move to TECHNICAL.md)');
+        issues++;
+        break;
+      }
+    }
+  } else {
+    warn('README.md not found');
+    issues++;
+  }
+
+  // Check sub-tools (toolbox mode)
+  const toolsDir = join(repoPath, 'tools');
+  if (existsSync(toolsDir)) {
+    try {
+      const entries = readdirSync(toolsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const toolPath = join(toolsDir, entry.name);
+        const toolLicense = join(toolPath, 'LICENSE');
+
+        if (!existsSync(toolLicense)) {
+          warn(`tools/${entry.name}/LICENSE missing`);
+          issues++;
+          if (FIX) {
+            writeFileSync(toolLicense, generateLicense(config));
+            ok(`tools/${entry.name}/LICENSE created (--fix)`);
+            issues--;
+          }
+        } else {
+          const text = readFileSync(toolLicense, 'utf8');
+          if (!text.includes(config.copyright)) {
+            warn(`tools/${entry.name}/LICENSE wrong copyright`);
+            issues++;
+            if (FIX) {
+              writeFileSync(toolLicense, generateLicense(config));
+              ok(`tools/${entry.name}/LICENSE updated (--fix)`);
+              issues--;
+            }
+          } else {
+            ok(`tools/${entry.name}/LICENSE correct`);
+          }
+        }
+      }
+    } catch {}
+  }
+
+  log('');
+  if (issues === 0) {
+    log('  All checks passed.\n');
+  } else {
+    log(`  ${issues} issue(s) found. Run with --fix to auto-repair.\n`);
+  }
+
+  return issues;
+}
+
+// Main
+if (command === 'init') {
+  await init(target === 'init' ? '.' : target);
+} else if (command === 'check') {
+  const repoPath = (target === 'check') ? '.' : target;
+  const issues = await check(repoPath);
+  process.exit(issues > 0 ? 1 : 0);
+} else if (command === '--help' || command === '-h' || command === 'help') {
+  console.log(`
+  wip-license-guard
+
+  Commands:
+    init [path]                Interactive setup. Asks license type, copyright, year.
+    init --from-standard       Apply WIP Computer defaults (MIT+AGPL, CLA, attribution).
+    check [path]               Audit repo against saved config. Exit 1 if issues found.
+    check --fix [path]         Auto-fix issues (update LICENSE files, wrong copyright).
+    help                       Show this help.
+
+  On first run, if no config exists, check will offer to run init.
+  Use --from-standard for new WIP Computer repos (no prompts, just works).
+
+  Config file: .license-guard.json (commit this to your repo)
+  `);
+} else {
+  console.error(`Unknown command: ${command}. Run wip-license-guard help.`);
+  process.exit(1);
+}

package/core.mjs

@@ -0,0 +1,145 @@
+// wip-license-guard/core.mjs
+// License generation and validation logic.
+
+export function generateLicense(config) {
+  const { copyright, license, year } = config;
+
+  if (license === 'MIT') return generateMIT(copyright, year);
+  if (license === 'AGPL-3.0') return generateAGPL(copyright, year);
+  if (license === 'MIT+AGPL') return generateDual(copyright, year);
+
+  return generateMIT(copyright, year);
+}
+
+function generateMIT(copyright, year) {
+  return `MIT License
+
+Copyright (c) ${year} ${copyright}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+}
+
+function generateAGPL(copyright, year) {
+  return `GNU Affero General Public License v3.0
+
+Copyright (c) ${year} ${copyright}
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+`;
+}
+
+function generateDual(copyright, year) {
+  return `Dual License: MIT + AGPLv3
+
+Copyright (c) ${year} ${copyright}
+
+
+1. MIT License (local and personal use)
+---------------------------------------
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+2. GNU Affero General Public License v3.0 (commercial and cloud use)
+--------------------------------------------------------------------
+
+If you run this software as part of a hosted service, cloud platform,
+marketplace listing, or any network-accessible offering for commercial
+purposes, the AGPLv3 terms apply. You must either:
+
+  a) Release your complete source code under AGPLv3, or
+  b) Obtain a commercial license.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+AGPLv3 for personal use is free. Commercial licenses available.
+`;
+}
+
+export function generateReadmeBlock(config) {
+  const { license, attribution } = config;
+
+  if (license === 'MIT') {
+    return `## License
+
+MIT.${attribution ? ' ' + attribution : ''}
+`;
+  }
+
+  if (license === 'AGPL-3.0') {
+    return `## License
+
+AGPLv3. AGPLv3 for personal use is free.${attribution ? '\n\n' + attribution : ''}
+`;
+  }
+
+  return `## License
+
+\`\`\`
+MIT      All CLI tools, MCP servers, skills, and hooks (use anywhere, no restrictions).
+AGPLv3   Commercial redistribution, marketplace listings, or bundling into paid services.
+\`\`\`
+
+Dual-license model designed to keep tools free while preventing commercial resellers.
+
+AGPLv3 for personal use is free. Commercial licenses available.
+
+Using these tools to build your own software is fine. Reselling the tools themselves is what requires a commercial license.
+${attribution ? '\n' + attribution : ''}`;
+}

package/hook.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+// wip-license-guard/hook.mjs
+// PreToolUse hook for Claude Code.
+// Blocks commits/pushes when license compliance fails.
+// Checks: LICENSE file, copyright, CLA.md, README license section.
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function deny(reason) {
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+  };
+  process.stdout.write(JSON.stringify(output));
+}
+
+function findRepoRoot(startPath) {
+  let dir = startPath;
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(join(dir, '.git'))) return dir;
+    const parent = join(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function checkLicenseCompliance(repoPath) {
+  const issues = [];
+  const configPath = join(repoPath, '.license-guard.json');
+
+  // No config means license-guard hasn't been set up. Don't block.
+  if (!existsSync(configPath)) return [];
+
+  const config = JSON.parse(readFileSync(configPath, 'utf8'));
+
+  // 1. LICENSE file must exist
+  const licensePath = join(repoPath, 'LICENSE');
+  if (!existsSync(licensePath)) {
+    issues.push('LICENSE file is missing');
+  } else {
+    const licenseText = readFileSync(licensePath, 'utf8');
+
+    // 2. Copyright must match
+    if (!licenseText.includes(config.copyright)) {
+      issues.push(`LICENSE copyright does not match "${config.copyright}"`);
+    }
+
+    // 3. Dual-license must include AGPL
+    if (config.license === 'MIT+AGPL' && !licenseText.includes('AGPL') && !licenseText.includes('GNU Affero')) {
+      issues.push('LICENSE is MIT-only but config requires MIT+AGPL');
+    }
+  }
+
+  // 4. CLA.md should exist for repos with contributors
+  if (!existsSync(join(repoPath, 'CLA.md'))) {
+    issues.push('CLA.md is missing');
+  }
+
+  // 5. README must have license section
+  const readmePath = join(repoPath, 'README.md');
+  if (existsSync(readmePath)) {
+    const readme = readFileSync(readmePath, 'utf8');
+    if (!readme.includes('## License')) {
+      issues.push('README.md missing ## License section');
+    }
+    if (config.license === 'MIT+AGPL' && !readme.includes('AGPL')) {
+      issues.push('README.md License section missing AGPL reference');
+    }
+  }
+
+  return issues;
+}
+
+// CLI mode: node hook.mjs --check [path]
+if (process.argv.includes('--check')) {
+  const path = process.argv[process.argv.indexOf('--check') + 1] || '.';
+  const issues = checkLicenseCompliance(path);
+  if (issues.length === 0) {
+    console.log('  All license checks passed.');
+    process.exit(0);
+  } else {
+    console.log('  License compliance issues:');
+    for (const issue of issues) console.log(`    - ${issue}`);
+    console.log('\n  Run `wip-license-guard check --fix` to auto-repair.');
+    process.exit(1);
+  }
+}
+
+async function main() {
+  let raw = '';
+  for await (const chunk of process.stdin) {
+    raw += chunk;
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const toolName = input.tool_name || '';
+
+  // Only check on Bash tool calls that look like git commit or git push
+  if (toolName !== 'Bash') {
+    process.exit(0);
+  }
+
+  const command = input.tool_input?.command || '';
+
+  // Check if this is a git commit or git push
+  const isCommit = /\bgit\s+commit\b/.test(command);
+  const isPush = /\bgit\s+push\b/.test(command);
+
+  if (!isCommit && !isPush) {
+    process.exit(0);
+  }
+
+  // Find repo root from cwd
+  const cwd = input.tool_input?.cwd || process.cwd();
+  const repoRoot = findRepoRoot(cwd);
+
+  if (!repoRoot) {
+    process.exit(0);
+  }
+
+  const issues = checkLicenseCompliance(repoRoot);
+
+  if (issues.length > 0) {
+    const issueList = issues.map(i => `  - ${i}`).join('\n');
+    deny(
+      `BLOCKED: License compliance check failed.\n${issueList}\n\nFix these issues before committing. Run \`wip-license-guard check --fix\` to auto-repair.`
+    );
+    process.exit(0);
+  }
+
+  // All good
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@wipcomputer/wip-license-guard",
+  "version": "1.0.0",
+  "description": "License compliance for your own repos. Ensures correct copyright, dual-license blocks, and LICENSE files.",
+  "type": "module",
+  "bin": {
+    "wip-license-guard": "./cli.mjs"
+  },
+  "license": "MIT AND AGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wipcomputer/wip-ai-devops-toolbox.git",
+    "directory": "tools/wip-license-guard"
+  }
+}