claude-auto 0.12.4

package/dist/src/validator-loader.test.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const vitest_1 = require("vitest");
+const validator_loader_js_1 = require("./validator-loader.js");
+(0, vitest_1.describe)('loadValidators', () => {
+    let tempDir;
+    (0, vitest_1.beforeEach)(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ketchup-validators-'));
+    });
+    (0, vitest_1.afterEach)(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)('returns empty array when directory does not exist', () => {
+        const nonExistentDir = path.join(tempDir, 'validators');
+        const result = (0, validator_loader_js_1.loadValidators)([nonExistentDir]);
+        (0, vitest_1.expect)(result).toEqual([]);
+    });
+    (0, vitest_1.it)('parses single .md file with frontmatter', () => {
+        const validatorsDir = path.join(tempDir, 'validators');
+        fs.mkdirSync(validatorsDir);
+        const validatorContent = `---
+name: test-validator
+description: A test validator
+enabled: true
+---
+
+Check that tests pass.
+
+Respond with JSON: {"decision":"ACK"} or {"decision":"NACK","reason":"..."}`;
+        fs.writeFileSync(path.join(validatorsDir, 'test.md'), validatorContent);
+        const result = (0, validator_loader_js_1.loadValidators)([validatorsDir]);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                name: 'test-validator',
+                description: 'A test validator',
+                enabled: true,
+                content: 'Check that tests pass.\n\nRespond with JSON: {"decision":"ACK"} or {"decision":"NACK","reason":"..."}',
+                path: path.join(validatorsDir, 'test.md'),
+            },
+        ]);
+    });
+    (0, vitest_1.it)('filters disabled validators', () => {
+        const validatorsDir = path.join(tempDir, 'validators');
+        fs.mkdirSync(validatorsDir);
+        fs.writeFileSync(path.join(validatorsDir, 'enabled.md'), `---
+name: enabled-validator
+description: Enabled
+enabled: true
+---
+Content`);
+        fs.writeFileSync(path.join(validatorsDir, 'disabled.md'), `---
+name: disabled-validator
+description: Disabled
+enabled: false
+---
+Content`);
+        const result = (0, validator_loader_js_1.loadValidators)([validatorsDir]);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                name: 'enabled-validator',
+                description: 'Enabled',
+                enabled: true,
+                content: 'Content',
+                path: path.join(validatorsDir, 'enabled.md'),
+            },
+        ]);
+    });
+    (0, vitest_1.it)('loads from multiple directories', () => {
+        const dir1 = path.join(tempDir, 'validators1');
+        const dir2 = path.join(tempDir, 'validators2');
+        fs.mkdirSync(dir1);
+        fs.mkdirSync(dir2);
+        fs.writeFileSync(path.join(dir1, 'first.md'), `---
+name: first
+description: First validator
+enabled: true
+---
+First content`);
+        fs.writeFileSync(path.join(dir2, 'second.md'), `---
+name: second
+description: Second validator
+enabled: true
+---
+Second content`);
+        const result = (0, validator_loader_js_1.loadValidators)([dir1, dir2]);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                name: 'first',
+                description: 'First validator',
+                enabled: true,
+                content: 'First content',
+                path: path.join(dir1, 'first.md'),
+            },
+            {
+                name: 'second',
+                description: 'Second validator',
+                enabled: true,
+                content: 'Second content',
+                path: path.join(dir2, 'second.md'),
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=validator-loader.test.js.map

package/dist/src/validator-loader.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator-loader.test.js","sourceRoot":"","sources":["../../src/validator-loader.test.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "claude-auto",
+  "version": "0.12.4",
+  "authors": [
+    {
+      "name": "Sam Hatoum"
+    }
+  ],
+  "description": "Husky-style hooks and skills management for Claude Code",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BeOnAuto/claude-auto.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "claude-auto": "dist/bin/cli.js"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,json,md}": [
+      "biome check --write --no-errors-on-unmatched"
+    ]
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "hooks",
+    "skills",
+    "automation"
+  ],
+  "author": "Sam Hatoum",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "cosmiconfig": "^9.0.0",
+    "gray-matter": "^4.0.3",
+    "micromatch": "^4.0.8",
+    "yaml": "^2.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@types/micromatch": "^4.0.10",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^1.6.1",
+    "esbuild": "^0.27.2",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "tsx": "^4.0.0",
+    "turbo": "^2.7.5",
+    "typescript": "^5.0.0",
+    "vitepress": "^1.6.4",
+    "vitest": "^1.0.0"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "templates/",
+    "scripts/",
+    "commands/",
+    ".claude-auto/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc && pnpm build:bundle",
+    "build:bundle": "esbuild scripts/session-start.ts scripts/pre-tool-use.ts scripts/user-prompt-submit.ts scripts/auto-continue.ts --bundle --platform=node --target=node18 --format=cjs --outdir=dist/bundle/scripts --external:typescript",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "check": "turbo run build type-check test && pnpm lint",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm publish",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "install:local": "pnpm tsx bin/cli.ts install --local"
+  }
+}

package/scripts/auto-continue.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env npx tsx
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { writeHookLog } from '../src/hook-logger.js';
+import { handleStop, type StopHookInput } from '../src/hooks/auto-continue.js';
+import { resolvePaths } from '../src/path-resolver.js';
+
+const claudeDir = path.resolve(process.cwd(), '.claude');
+const stdin = fs.readFileSync(0, 'utf8').trim();
+
+if (!stdin) {
+  process.exit(0);
+}
+
+const input: StopHookInput = JSON.parse(stdin);
+const startTime = Date.now();
+
+(async () => {
+  const { autoDir } = await resolvePaths(claudeDir);
+  const result = handleStop(autoDir, input);
+
+  const output =
+    result.decision === 'block' ? { stopReason: result.reason, forceResult: { behaviour: 'block' } } : null;
+
+  writeHookLog(autoDir, {
+    hookName: 'auto-continue',
+    timestamp: new Date().toISOString(),
+    input,
+    output: output ?? { decision: result.decision, reason: result.reason },
+    durationMs: Date.now() - startTime,
+  });
+
+  if (output) {
+    console.log(JSON.stringify(output));
+  }
+
+  process.exit(0);
+})();

package/scripts/generate-changeset.ts

@@ -0,0 +1,405 @@
+#!/usr/bin/env tsx
+/**
+ * AI-powered changeset generation script
+ *
+ * This script:
+ * 1. Gets commits since last changeset/tag
+ * 2. Parses conventional commits (feat/fix/etc)
+ * 3. Determines bump type (breaking→major, feat→minor, else→patch)
+ * 4. Generates changelog via Claude CLI (with simple fallback)
+ * 5. Creates .changeset/*.md file
+ */
+
+import { execSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Exit codes
+const EXIT_CODE = {
+  SUCCESS: 0,
+  ERROR: 1,
+  NO_COMMITS: 11,
+  NO_CONVENTIONAL_COMMITS: 12,
+};
+
+// Types
+type CommitType =
+  | 'feat'
+  | 'fix'
+  | 'docs'
+  | 'style'
+  | 'refactor'
+  | 'perf'
+  | 'test'
+  | 'build'
+  | 'ci'
+  | 'chore'
+  | 'revert';
+type BumpType = 'major' | 'minor' | 'patch';
+
+interface ConventionalCommit {
+  hash: string;
+  type: CommitType;
+  scope?: string;
+  subject: string;
+  body?: string;
+  breaking: boolean;
+  fullMessage: string;
+}
+
+// Conventional commit pattern
+const CONVENTIONAL_PATTERN = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(([^)]+)\))?: (.+)/;
+
+// Configuration
+const CHANGESET_DIR = '.changeset';
+const PACKAGE_NAME = 'claude-auto';
+
+// Logging utilities
+function logStep(message: string): void {
+  console.log(`\n📋 ${message}`);
+}
+
+function logInfo(message: string): void {
+  console.log(`   ${message}`);
+}
+
+function logSuccess(message: string): void {
+  console.log(`✅ ${message}`);
+}
+
+function logWarning(message: string): void {
+  console.warn(`⚠️  ${message}`);
+}
+
+function logError(message: string): void {
+  console.error(`❌ ${message}`);
+}
+
+// Git utilities
+function isGitRepository(): boolean {
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getCommitMessage(hash: string): string {
+  return execSync(`git log -1 --format=%B ${hash}`, { encoding: 'utf8' }).trim();
+}
+
+function getCommitsSinceLastChangeset(): string[] {
+  try {
+    const changesetPath = join(process.cwd(), CHANGESET_DIR);
+
+    if (!existsSync(changesetPath)) {
+      return getCommitsSinceLastTag();
+    }
+
+    const files = readdirSync(changesetPath).filter((f) => f.endsWith('.md') && f !== 'README.md');
+
+    if (files.length === 0) {
+      return getCommitsSinceLastTag();
+    }
+
+    // Get the most recent changeset file by git commit time
+    const latestChangeset = files
+      .map((f) => {
+        try {
+          const time = execSync(`git log -1 --format=%ct -- ${CHANGESET_DIR}/${f}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          return { file: f, time: Number(time) || 0 };
+        } catch {
+          return { file: f, time: 0 };
+        }
+      })
+      .filter((f) => f.time > 0)
+      .sort((a, b) => b.time - a.time)[0];
+
+    if (!latestChangeset) {
+      return getCommitsSinceLastTag();
+    }
+
+    // Get commits since that changeset was added
+    const changesetCommit = execSync(`git log -1 --format=%H -- ${CHANGESET_DIR}/${latestChangeset.file}`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    return getCommitsInRange(changesetCommit, 'HEAD');
+  } catch (error) {
+    logWarning(`Could not get commits since last changeset: ${(error as Error).message}`);
+    return [];
+  }
+}
+
+function getCommitsInRange(since: string, until = 'HEAD'): string[] {
+  try {
+    const output = execSync(`git log ${since}..${until} --format=%H`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    return output ? output.split('\n').filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function getCommitsSinceLastTag(): string[] {
+  try {
+    const lastTag = execSync('git describe --tags --abbrev=0', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    return getCommitsInRange(lastTag, 'HEAD');
+  } catch {
+    // No tags exist, get recent commits (limit to 50)
+    try {
+      const output = execSync('git log -50 --format=%H', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+
+      return output ? output.split('\n').filter(Boolean) : [];
+    } catch {
+      return [];
+    }
+  }
+}
+
+// Parsing utilities
+function parseConventionalCommit(hash: string): ConventionalCommit | null {
+  try {
+    const fullMessage = getCommitMessage(hash);
+    const match = fullMessage.match(CONVENTIONAL_PATTERN);
+
+    if (!match) {
+      return null;
+    }
+
+    const [, type, , scope, subject] = match;
+    const body = fullMessage.split('\n').slice(1).join('\n').trim();
+    const breaking = fullMessage.includes('BREAKING CHANGE:') || fullMessage.includes('!:');
+
+    return {
+      hash,
+      type: type as CommitType,
+      scope,
+      subject,
+      body,
+      breaking,
+      fullMessage,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function parseConventionalCommits(hashes: string[]): ConventionalCommit[] {
+  return hashes.map((hash) => parseConventionalCommit(hash)).filter((c): c is ConventionalCommit => c !== null);
+}
+
+// Semver utilities
+function determineBumpType(commits: ConventionalCommit[]): BumpType {
+  if (commits.some((c) => c.breaking)) {
+    return 'major';
+  }
+
+  if (commits.some((c) => c.type === 'feat')) {
+    return 'minor';
+  }
+
+  return 'patch';
+}
+
+// Changelog generation
+async function generateChangelogWithClaude(commits: ConventionalCommit[]): Promise<string | null> {
+  try {
+    // Check if claude CLI is available
+    execSync('which claude', { stdio: 'pipe' });
+
+    const commitSummary = commits
+      .map((c) => `- ${c.type}${c.scope ? `(${c.scope})` : ''}: ${c.subject}\n  ${c.body || '(no additional details)'}`)
+      .join('\n\n');
+
+    const prompt = `You are analyzing git commits to generate a changelog entry. Here are the commits:
+
+${commitSummary}
+
+Generate a concise changelog description as bullet points. Rules:
+- Use 2-5 bullet points maximum
+- Focus on user-facing changes and impact
+- Group related changes together
+- Use clear, non-technical language where possible
+- Start each bullet with a dash and capitalize the first word
+- Do NOT include commit hashes, types, or scopes
+- Do NOT use markdown formatting besides the dashes
+
+Example format:
+- Added user authentication with OAuth support
+- Fixed critical bug in data synchronization
+- Improved performance of search queries by 50%
+
+Now generate the changelog for the commits above:`;
+
+    const tempFile = join(process.cwd(), `.changeset-prompt-${Date.now()}.txt`);
+    writeFileSync(tempFile, prompt);
+
+    try {
+      const result = execSync(`claude -p --no-session-persistence "$(cat ${tempFile})"`, {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 30000,
+      });
+
+      return result.trim();
+    } finally {
+      try {
+        execSync(`rm ${tempFile}`, { stdio: 'pipe' });
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+
+function generateSimpleChangelog(commits: ConventionalCommit[]): string {
+  const features = commits.filter((c) => c.type === 'feat');
+  const fixes = commits.filter((c) => c.type === 'fix');
+  const others = commits.filter((c) => !['feat', 'fix'].includes(c.type));
+
+  const lines: string[] = [];
+
+  if (features.length > 0) {
+    lines.push(...features.map((c) => `- ${c.scope ? `**${c.scope}**: ` : ''}${c.subject}`));
+  }
+
+  if (fixes.length > 0) {
+    lines.push(...fixes.map((c) => `- ${c.scope ? `**${c.scope}**: ` : ''}${c.subject}`));
+  }
+
+  if (others.length > 0 && lines.length < 5) {
+    lines.push(...others.map((c) => `- ${c.scope ? `**${c.scope}**: ` : ''}${c.subject}`).slice(0, 5 - lines.length));
+  }
+
+  return lines.slice(0, 5).join('\n');
+}
+
+async function generateChangelog(commits: ConventionalCommit[]): Promise<string> {
+  logInfo('Attempting to generate changelog with Claude CLI...');
+
+  const aiChangelog = await generateChangelogWithClaude(commits);
+
+  if (aiChangelog) {
+    logSuccess('Changelog generated with Claude CLI');
+    return aiChangelog;
+  }
+
+  logWarning('Claude CLI not available, using simple changelog generation');
+  return generateSimpleChangelog(commits);
+}
+
+// Changeset file creation
+function createChangesetFile(bumpType: BumpType, description: string): { filename: string; content: string } {
+  const changesetDir = join(process.cwd(), CHANGESET_DIR);
+
+  if (!existsSync(changesetDir)) {
+    mkdirSync(changesetDir, { recursive: true });
+  }
+
+  const id = randomBytes(8).toString('hex');
+  const filename = `auto-${id}.md`;
+  const filepath = join(changesetDir, filename);
+
+  const content = `---
+"${PACKAGE_NAME}": ${bumpType}
+---
+
+${description}
+`;
+
+  writeFileSync(filepath, content);
+
+  return { filename, content };
+}
+
+// Main function
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+
+  try {
+    if (!isGitRepository()) {
+      logError('Not a git repository');
+      process.exit(EXIT_CODE.ERROR);
+    }
+
+    logStep('Checking for commits that need changesets...');
+
+    const commitHashes = getCommitsSinceLastChangeset();
+
+    if (commitHashes.length === 0) {
+      logInfo('No new commits found. Nothing to do.');
+      process.exit(EXIT_CODE.NO_COMMITS);
+    }
+
+    logInfo(`Found ${commitHashes.length} commit(s) to process`);
+
+    const commits = parseConventionalCommits(commitHashes);
+
+    const skippedCount = commitHashes.length - commits.length;
+    if (skippedCount > 0) {
+      logWarning(`Skipped ${skippedCount} non-conventional commit(s). Use format: type(scope): subject`);
+    }
+
+    if (commits.length === 0) {
+      logWarning('No conventional commits found. Skipping changeset generation.');
+      logInfo('Commits must follow format: type(scope): subject (e.g., feat(cli): add new command)');
+      process.exit(EXIT_CODE.NO_CONVENTIONAL_COMMITS);
+    }
+
+    logSuccess(`Found ${commits.length} valid conventional commit(s)`);
+
+    const bumpType = determineBumpType(commits);
+    logInfo(`Determined version bump: ${bumpType}`);
+
+    const description = await generateChangelog(commits);
+
+    if (dryRun) {
+      console.log('\n📋 Changeset Preview:');
+      console.log('---');
+      console.log(`Bump type: ${bumpType}`);
+      console.log(`Package: ${PACKAGE_NAME}`);
+      console.log('\nChangelog:');
+      console.log(description);
+      console.log('---');
+      process.exit(EXIT_CODE.SUCCESS);
+    }
+
+    const result = createChangesetFile(bumpType, description);
+
+    logSuccess(`Created changeset: ${result.filename}`);
+    logInfo(`  Bump type: ${bumpType}`);
+    logInfo(`  Commits: ${commits.length}`);
+
+    console.log('\n📋 Changelog preview:');
+    console.log('---');
+    console.log(description);
+    console.log('---');
+
+    process.exit(EXIT_CODE.SUCCESS);
+  } catch (error) {
+    logError(`Failed to generate changeset: ${(error as Error).message}`);
+    process.exit(EXIT_CODE.ERROR);
+  }
+}
+
+main();