@gallop.software/canon 1.0.0 → 2.0.1

package/dist/cli/commands/audit.d.ts

@@ -0,0 +1,7 @@
+interface AuditOptions {
+    strict: boolean;
+    json: boolean;
+    fix: boolean;
+}
+export declare function audit(path: string, options: AuditOptions): Promise<void>;
+export {};

package/dist/cli/commands/audit.js

@@ -0,0 +1,172 @@
+import { spawn } from 'child_process';
+import { version, patterns, getPattern } from '../../index.js';
+// Colors for terminal output
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+// Build rule-to-pattern mapping from Canon schema (single source of truth)
+const ruleToPattern = {};
+for (const pattern of patterns) {
+    if (pattern.rule) {
+        ruleToPattern[pattern.rule] = pattern.id;
+    }
+}
+function parseCanonFromMessage(message) {
+    const match = message.match(/\[Canon (\d{3})\]/);
+    return match ? match[1] : null;
+}
+function extractViolations(eslintOutput) {
+    const violations = [];
+    const lines = eslintOutput.split('\n');
+    let currentFile = '';
+    for (const line of lines) {
+        // File path line (starts with /)
+        if (line.startsWith('/') && !line.includes(':')) {
+            currentFile = line.trim();
+            continue;
+        }
+        // Violation line (starts with spaces, has line:col pattern)
+        const match = line.match(/^\s+(\d+):(\d+)\s+(warning|error)\s+(.+?)\s{2,}([\w/-]+)$/);
+        if (match && currentFile) {
+            const [, lineNum, column, , message, ruleId] = match;
+            const canonPattern = ruleToPattern[ruleId] || parseCanonFromMessage(message);
+            const pattern = canonPattern ? getPattern(canonPattern) : null;
+            violations.push({
+                file: currentFile,
+                line: parseInt(lineNum, 10),
+                column: parseInt(column, 10),
+                message: message.trim(),
+                ruleId,
+                canonPattern,
+                patternTitle: pattern?.title || null,
+            });
+        }
+    }
+    return violations;
+}
+function countByPattern(violations) {
+    const counts = {};
+    for (const v of violations) {
+        const key = v.canonPattern || 'other';
+        counts[key] = (counts[key] || 0) + 1;
+    }
+    return counts;
+}
+function groupByFile(violations) {
+    const groups = new Map();
+    for (const v of violations) {
+        const existing = groups.get(v.file) || [];
+        existing.push(v);
+        groups.set(v.file, existing);
+    }
+    return groups;
+}
+function printReport(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Header
+    console.log('');
+    console.log(`${c.bold}╔════════════════════════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.bold}║${c.reset}           ${c.cyan}Gallop Canon${c.reset} ${c.dim}v${result.version}${c.reset} ${c.bold}Compliance Report${c.reset}           ${c.bold}║${c.reset}`);
+    console.log(`${c.bold}╚════════════════════════════════════════════════════════════╝${c.reset}`);
+    console.log('');
+    if (result.violations.length === 0) {
+        console.log(`  ${c.green}✓${c.reset} ${c.bold}All files pass Canon compliance checks${c.reset}`);
+        console.log(`  ${c.dim}Path: ${result.path}${c.reset}`);
+        console.log('');
+        return;
+    }
+    // Summary
+    const filesWithViolations = new Set(result.violations.map(v => v.file)).size;
+    console.log(`  ${c.red}✗${c.reset} ${c.bold}${result.violations.length} violation${result.violations.length === 1 ? '' : 's'}${c.reset} in ${filesWithViolations} file${filesWithViolations === 1 ? '' : 's'}`);
+    console.log(`  ${c.dim}Path: ${result.path}${c.reset}`);
+    console.log('');
+    // Violations by pattern
+    console.log(`${c.bold}  Violations by Pattern:${c.reset}`);
+    for (const [patternId, count] of Object.entries(result.summary.byPattern).sort()) {
+        const pattern = getPattern(patternId);
+        const title = pattern?.title || 'Other';
+        console.log(`    ${c.yellow}${patternId}${c.reset} ${title}: ${c.bold}${count}${c.reset}`);
+    }
+    console.log('');
+    // Detailed violations by file
+    console.log(`${c.bold}  Details:${c.reset}`);
+    console.log('');
+    const byFile = groupByFile(result.violations);
+    for (const [file, violations] of byFile) {
+        // Shorten file path for display
+        const shortPath = file.replace(process.cwd() + '/', '');
+        console.log(`  ${c.cyan}${shortPath}${c.reset}`);
+        for (const v of violations) {
+            const patternLabel = v.canonPattern
+                ? `${c.yellow}[${v.canonPattern}]${c.reset}`
+                : `${c.dim}[---]${c.reset}`;
+            const location = `${c.dim}${v.line}:${v.column}${c.reset}`;
+            // Clean up message (remove [Canon XXX] prefix since we show it separately)
+            const cleanMessage = v.message.replace(/\[Canon \d{3}\]\s*/, '');
+            console.log(`    ${location} ${patternLabel} ${cleanMessage}`);
+        }
+        console.log('');
+    }
+    // Footer
+    console.log(`${c.dim}  ─────────────────────────────────────────────────────────${c.reset}`);
+    console.log(`  ${c.dim}Fix violations manually following the Canon patterns${c.reset}`);
+    console.log('');
+}
+export async function audit(path, options) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            'eslint',
+            path,
+            '--format', 'stylish',
+        ];
+        if (options.fix) {
+            args.push('--fix');
+        }
+        const eslint = spawn('npx', args, {
+            cwd: process.cwd(),
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        eslint.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        eslint.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        eslint.on('close', (code) => {
+            const violations = extractViolations(stdout);
+            const result = {
+                version,
+                timestamp: new Date().toISOString(),
+                path,
+                totalFiles: 0, // ESLint stylish format doesn't give us this easily
+                violations,
+                summary: {
+                    total: violations.length,
+                    byPattern: countByPattern(violations),
+                },
+            };
+            printReport(result, options);
+            if (options.strict && violations.length > 0) {
+                process.exit(1);
+            }
+            resolve();
+        });
+        eslint.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../../src/cli/commands/audit.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn } from 'child_process'\nimport { version, patterns, getPattern } from '../../index.js'\n\ninterface AuditOptions {\n  strict: boolean\n  json: boolean\n  fix: boolean\n}\n\ninterface Violation {\n  file: string\n  line: number\n  column: number\n  message: string\n  ruleId: string\n  canonPattern: string | null\n  patternTitle: string | null\n}\n\ninterface AuditResult {\n  version: string\n  timestamp: string\n  path: string\n  totalFiles: number\n  violations: Violation[]\n  summary: {\n    total: number\n    byPattern: Record<string, number>\n  }\n}\n\n// Colors for terminal output\nconst c = {\n  reset: '\\x1b[0m',\n  bold: '\\x1b[1m',\n  dim: '\\x1b[2m',\n  red: '\\x1b[31m',\n  green: '\\x1b[32m',\n  yellow: '\\x1b[33m',\n  blue: '\\x1b[34m',\n  cyan: '\\x1b[36m',\n}\n\n// Build rule-to-pattern mapping from Canon schema (single source of truth)\nconst ruleToPattern: Record<string, string> = {}\nfor (const pattern of patterns) {\n  if (pattern.rule) {\n    ruleToPattern[pattern.rule] = pattern.id\n  }\n}\n\nfunction parseCanonFromMessage(message: string): string | null {\n  const match = message.match(/\\[Canon (\\d{3})\\]/)\n  return match ? match[1] : null\n}\n\nfunction extractViolations(eslintOutput: string): Violation[] {\n  const violations: Violation[] = []\n  const lines = eslintOutput.split('\\n')\n  \n  let currentFile = ''\n  \n  for (const line of lines) {\n    // File path line (starts with /)\n    if (line.startsWith('/') && !line.includes(':')) {\n      currentFile = line.trim()\n      continue\n    }\n    \n    // Violation line (starts with spaces, has line:col pattern)\n    const match = line.match(/^\\s+(\\d+):(\\d+)\\s+(warning|error)\\s+(.+?)\\s{2,}([\\w/-]+)$/)\n    if (match && currentFile) {\n      const [, lineNum, column, , message, ruleId] = match\n      const canonPattern = ruleToPattern[ruleId] || parseCanonFromMessage(message)\n      const pattern = canonPattern ? getPattern(canonPattern) : null\n      \n      violations.push({\n        file: currentFile,\n        line: parseInt(lineNum, 10),\n        column: parseInt(column, 10),\n        message: message.trim(),\n        ruleId,\n        canonPattern,\n        patternTitle: pattern?.title || null,\n      })\n    }\n  }\n  \n  return violations\n}\n\nfunction countByPattern(violations: Violation[]): Record<string, number> {\n  const counts: Record<string, number> = {}\n  for (const v of violations) {\n    const key = v.canonPattern || 'other'\n    counts[key] = (counts[key] || 0) + 1\n  }\n  return counts\n}\n\nfunction groupByFile(violations: Violation[]): Map<string, Violation[]> {\n  const groups = new Map<string, Violation[]>()\n  for (const v of violations) {\n    const existing = groups.get(v.file) || []\n    existing.push(v)\n    groups.set(v.file, existing)\n  }\n  return groups\n}\n\nfunction printReport(result: AuditResult, options: AuditOptions) {\n  if (options.json) {\n    console.log(JSON.stringify(result, null, 2))\n    return\n  }\n\n  // Header\n  console.log('')\n  console.log(`${c.bold}╔════════════════════════════════════════════════════════════╗${c.reset}`)\n  console.log(`${c.bold}║${c.reset}           ${c.cyan}Gallop Canon${c.reset} ${c.dim}v${result.version}${c.reset} ${c.bold}Compliance Report${c.reset}           ${c.bold}║${c.reset}`)\n  console.log(`${c.bold}╚════════════════════════════════════════════════════════════╝${c.reset}`)\n  console.log('')\n\n  if (result.violations.length === 0) {\n    console.log(`  ${c.green}✓${c.reset} ${c.bold}All files pass Canon compliance checks${c.reset}`)\n    console.log(`  ${c.dim}Path: ${result.path}${c.reset}`)\n    console.log('')\n    return\n  }\n\n  // Summary\n  const filesWithViolations = new Set(result.violations.map(v => v.file)).size\n  console.log(`  ${c.red}✗${c.reset} ${c.bold}${result.violations.length} violation${result.violations.length === 1 ? '' : 's'}${c.reset} in ${filesWithViolations} file${filesWithViolations === 1 ? '' : 's'}`)\n  console.log(`  ${c.dim}Path: ${result.path}${c.reset}`)\n  console.log('')\n\n  // Violations by pattern\n  console.log(`${c.bold}  Violations by Pattern:${c.reset}`)\n  for (const [patternId, count] of Object.entries(result.summary.byPattern).sort()) {\n    const pattern = getPattern(patternId)\n    const title = pattern?.title || 'Other'\n    console.log(`    ${c.yellow}${patternId}${c.reset} ${title}: ${c.bold}${count}${c.reset}`)\n  }\n  console.log('')\n\n  // Detailed violations by file\n  console.log(`${c.bold}  Details:${c.reset}`)\n  console.log('')\n\n  const byFile = groupByFile(result.violations)\n  for (const [file, violations] of byFile) {\n    // Shorten file path for display\n    const shortPath = file.replace(process.cwd() + '/', '')\n    console.log(`  ${c.cyan}${shortPath}${c.reset}`)\n    \n    for (const v of violations) {\n      const patternLabel = v.canonPattern \n        ? `${c.yellow}[${v.canonPattern}]${c.reset}` \n        : `${c.dim}[---]${c.reset}`\n      const location = `${c.dim}${v.line}:${v.column}${c.reset}`\n      \n      // Clean up message (remove [Canon XXX] prefix since we show it separately)\n      const cleanMessage = v.message.replace(/\\[Canon \\d{3}\\]\\s*/, '')\n      \n      console.log(`    ${location} ${patternLabel} ${cleanMessage}`)\n    }\n    console.log('')\n  }\n\n  // Footer\n  console.log(`${c.dim}  ─────────────────────────────────────────────────────────${c.reset}`)\n  console.log(`  ${c.dim}Fix violations manually following the Canon patterns${c.reset}`)\n  console.log('')\n}\n\nexport async function audit(path: string, options: AuditOptions): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const args = [\n      'eslint',\n      path,\n      '--format', 'stylish',\n    ]\n\n    if (options.fix) {\n      args.push('--fix')\n    }\n\n    const eslint = spawn('npx', args, {\n      cwd: process.cwd(),\n      stdio: ['inherit', 'pipe', 'pipe'],\n      shell: true,\n    })\n\n    let stdout = ''\n    let stderr = ''\n\n    eslint.stdout?.on('data', (data) => {\n      stdout += data.toString()\n    })\n\n    eslint.stderr?.on('data', (data) => {\n      stderr += data.toString()\n    })\n\n    eslint.on('close', (code) => {\n      const violations = extractViolations(stdout)\n      \n      const result: AuditResult = {\n        version,\n        timestamp: new Date().toISOString(),\n        path,\n        totalFiles: 0, // ESLint stylish format doesn't give us this easily\n        violations,\n        summary: {\n          total: violations.length,\n          byPattern: countByPattern(violations),\n        },\n      }\n\n      printReport(result, options)\n\n      if (options.strict && violations.length > 0) {\n        process.exit(1)\n      }\n\n      resolve()\n    })\n\n    eslint.on('error', (error) => {\n      reject(error)\n    })\n  })\n}\n"]}

package/dist/cli/commands/generate.d.ts

@@ -0,0 +1,6 @@
+interface GenerateOptions {
+    output: string;
+    format: 'cursorrules' | 'markdown';
+}
+export declare function generate(options: GenerateOptions): Promise<void>;
+export {};

package/dist/cli/commands/generate.js

@@ -0,0 +1,170 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { version, patterns, guarantees } from '../../index.js';
+/**
+ * Read a pattern markdown file and extract sections
+ */
+function readPatternFile(patternFile) {
+    // Try to find the canon package patterns directory
+    const possiblePaths = [
+        path.join(process.cwd(), 'node_modules/@gallop.software/canon', patternFile),
+        // Fallback for development
+        path.join(import.meta.dirname, '../../../', patternFile),
+    ];
+    for (const filePath of possiblePaths) {
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+    }
+    return null;
+}
+/**
+ * Extract examples from pattern markdown
+ */
+function extractExamples(content) {
+    const good = [];
+    const bad = [];
+    // Find code blocks after "### Good" or "### Bad" headers
+    const goodMatch = content.match(/### Good\s*\n```[\s\S]*?```/g);
+    const badMatch = content.match(/### Bad\s*\n```[\s\S]*?```/g);
+    if (goodMatch) {
+        for (const match of goodMatch) {
+            const code = match.replace(/### Good\s*\n/, '').trim();
+            good.push(code);
+        }
+    }
+    if (badMatch) {
+        for (const match of badMatch) {
+            const code = match.replace(/### Bad\s*\n/, '').trim();
+            bad.push(code);
+        }
+    }
+    return { good, bad };
+}
+/**
+ * Generate .cursorrules content from Canon
+ */
+function generateCursorrules() {
+    const lines = [];
+    // Header
+    lines.push(`# Gallop Canon v${version} - AI Rules`);
+    lines.push('');
+    lines.push('This file is auto-generated from @gallop.software/canon. Do not edit manually.');
+    lines.push('Regenerate with: npm run generate:ai-rules');
+    lines.push('');
+    // Tech stack (from speedwell context)
+    lines.push('## Tech Stack');
+    lines.push('');
+    lines.push('- Next.js 16 with App Router');
+    lines.push('- React 19');
+    lines.push('- TypeScript');
+    lines.push('- Tailwind CSS v4');
+    lines.push('- clsx for conditional class names');
+    lines.push('');
+    // Enforced patterns (ESLint rules)
+    lines.push('## Enforced Patterns (ESLint)');
+    lines.push('');
+    lines.push('These patterns are enforced by `@gallop.software/canon/eslint`. Violations will be flagged.');
+    lines.push('');
+    const enforcedPatterns = patterns.filter(p => p.enforcement === 'eslint' && p.rule);
+    for (const pattern of enforcedPatterns) {
+        lines.push(`### ${pattern.id}: ${pattern.title}`);
+        lines.push('');
+        lines.push(pattern.summary);
+        lines.push('');
+        lines.push(`- **ESLint Rule:** \`${pattern.rule}\``);
+        lines.push(`- **Category:** ${pattern.category}`);
+        lines.push('');
+        // Try to read and include examples
+        const content = readPatternFile(pattern.file);
+        if (content) {
+            const { good, bad } = extractExamples(content);
+            if (bad.length > 0) {
+                lines.push('**Bad:**');
+                lines.push('');
+                lines.push(bad[0]);
+                lines.push('');
+            }
+            if (good.length > 0) {
+                lines.push('**Good:**');
+                lines.push('');
+                lines.push(good[0]);
+                lines.push('');
+            }
+        }
+    }
+    // Documentation patterns
+    lines.push('## Documentation Patterns');
+    lines.push('');
+    lines.push('These patterns are not enforced by ESLint but should be followed.');
+    lines.push('');
+    const docPatterns = patterns.filter(p => p.enforcement === 'documentation');
+    for (const pattern of docPatterns) {
+        lines.push(`### ${pattern.id}: ${pattern.title}`);
+        lines.push('');
+        lines.push(pattern.summary);
+        lines.push('');
+    }
+    // Guarantees
+    lines.push('## Canon Guarantees');
+    lines.push('');
+    lines.push('Following these patterns provides these guarantees:');
+    lines.push('');
+    for (const guarantee of guarantees) {
+        lines.push(`- **${guarantee.name}** (${guarantee.id}): Patterns ${guarantee.patterns.join(', ')}`);
+    }
+    lines.push('');
+    // Quick reference for components
+    lines.push('## Component Quick Reference');
+    lines.push('');
+    lines.push('### Typography');
+    lines.push('- `Heading` - props: `as`, `color`, `margin`, `fontSize`, `fontWeight`, `textAlign`');
+    lines.push('- `Paragraph` - props: `color`, `margin`, `fontSize`, `lineHeight`, `textAlign`');
+    lines.push('- `Span` - props: `color`, `margin`, `fontSize` (inline text, mb-0 default)');
+    lines.push('- `Label` - props: `color`, `margin`, `fontSize`, `fontWeight`, `textAlign`');
+    lines.push('');
+    lines.push('### Layout');
+    lines.push('- `Section` - semantic section wrapper');
+    lines.push('- `Columns` - grid layout, props: `cols`, `gap`, `align`');
+    lines.push('- `Column` - column child');
+    lines.push('');
+    lines.push('### Interactive');
+    lines.push('- `Button` - props: `href`, `variant`, `icon`, `iconPlacement`, `margin`');
+    lines.push('- `Icon` - Iconify icon wrapper');
+    lines.push('');
+    // Do NOT section
+    lines.push('## Do NOT');
+    lines.push('');
+    lines.push('- Use `\'use client\'` in blocks - extract to components');
+    lines.push('- Use raw `<p>` or `<span>` - use Paragraph/Span components');
+    lines.push('- Use className for margin/color/fontSize when component has props');
+    lines.push('- Use Container inside Section - Section already provides containment');
+    lines.push('- Use `classnames` package - use `clsx` instead');
+    lines.push('- Use inline styles for hover states - use Tailwind classes');
+    lines.push('');
+    // Post-edit verification
+    lines.push('## Post-Edit Verification');
+    lines.push('');
+    lines.push('After editing files:');
+    lines.push('1. Run `npm run lint` to check for errors');
+    lines.push('2. Fix any violations before committing');
+    lines.push('');
+    lines.push('Note: Only lint files you edited, not the entire codebase.');
+    lines.push('');
+    return lines.join('\n');
+}
+export async function generate(options) {
+    const content = generateCursorrules();
+    if (options.output === '-') {
+        // Output to stdout
+        console.log(content);
+    }
+    else {
+        // Write to file
+        const outputPath = path.resolve(process.cwd(), options.output);
+        fs.writeFileSync(outputPath, content, 'utf-8');
+        console.log(`✓ Generated ${options.output} from Canon v${version}`);
+        console.log(`  ${patterns.length} patterns, ${guarantees.length} guarantees`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate.js","sourceRoot":"","sources":["../../../src/cli/commands/generate.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs'\nimport * as path from 'path'\nimport { version, patterns, categories, guarantees } from '../../index.js'\n\ninterface GenerateOptions {\n  output: string\n  format: 'cursorrules' | 'markdown'\n}\n\n/**\n * Read a pattern markdown file and extract sections\n */\nfunction readPatternFile(patternFile: string): string | null {\n  // Try to find the canon package patterns directory\n  const possiblePaths = [\n    path.join(process.cwd(), 'node_modules/@gallop.software/canon', patternFile),\n    // Fallback for development\n    path.join(import.meta.dirname, '../../../', patternFile),\n  ]\n\n  for (const filePath of possiblePaths) {\n    if (fs.existsSync(filePath)) {\n      return fs.readFileSync(filePath, 'utf-8')\n    }\n  }\n\n  return null\n}\n\n/**\n * Extract examples from pattern markdown\n */\nfunction extractExamples(content: string): { good: string[]; bad: string[] } {\n  const good: string[] = []\n  const bad: string[] = []\n\n  // Find code blocks after \"### Good\" or \"### Bad\" headers\n  const goodMatch = content.match(/### Good\\s*\\n```[\\s\\S]*?```/g)\n  const badMatch = content.match(/### Bad\\s*\\n```[\\s\\S]*?```/g)\n\n  if (goodMatch) {\n    for (const match of goodMatch) {\n      const code = match.replace(/### Good\\s*\\n/, '').trim()\n      good.push(code)\n    }\n  }\n\n  if (badMatch) {\n    for (const match of badMatch) {\n      const code = match.replace(/### Bad\\s*\\n/, '').trim()\n      bad.push(code)\n    }\n  }\n\n  return { good, bad }\n}\n\n/**\n * Generate .cursorrules content from Canon\n */\nfunction generateCursorrules(): string {\n  const lines: string[] = []\n\n  // Header\n  lines.push(`# Gallop Canon v${version} - AI Rules`)\n  lines.push('')\n  lines.push('This file is auto-generated from @gallop.software/canon. Do not edit manually.')\n  lines.push('Regenerate with: npm run generate:ai-rules')\n  lines.push('')\n\n  // Tech stack (from speedwell context)\n  lines.push('## Tech Stack')\n  lines.push('')\n  lines.push('- Next.js 16 with App Router')\n  lines.push('- React 19')\n  lines.push('- TypeScript')\n  lines.push('- Tailwind CSS v4')\n  lines.push('- clsx for conditional class names')\n  lines.push('')\n\n  // Enforced patterns (ESLint rules)\n  lines.push('## Enforced Patterns (ESLint)')\n  lines.push('')\n  lines.push('These patterns are enforced by `@gallop.software/canon/eslint`. Violations will be flagged.')\n  lines.push('')\n\n  const enforcedPatterns = patterns.filter(p => p.enforcement === 'eslint' && p.rule)\n  for (const pattern of enforcedPatterns) {\n    lines.push(`### ${pattern.id}: ${pattern.title}`)\n    lines.push('')\n    lines.push(pattern.summary)\n    lines.push('')\n    lines.push(`- **ESLint Rule:** \\`${pattern.rule}\\``)\n    lines.push(`- **Category:** ${pattern.category}`)\n    lines.push('')\n\n    // Try to read and include examples\n    const content = readPatternFile(pattern.file)\n    if (content) {\n      const { good, bad } = extractExamples(content)\n      if (bad.length > 0) {\n        lines.push('**Bad:**')\n        lines.push('')\n        lines.push(bad[0])\n        lines.push('')\n      }\n      if (good.length > 0) {\n        lines.push('**Good:**')\n        lines.push('')\n        lines.push(good[0])\n        lines.push('')\n      }\n    }\n  }\n\n  // Documentation patterns\n  lines.push('## Documentation Patterns')\n  lines.push('')\n  lines.push('These patterns are not enforced by ESLint but should be followed.')\n  lines.push('')\n\n  const docPatterns = patterns.filter(p => p.enforcement === 'documentation')\n  for (const pattern of docPatterns) {\n    lines.push(`### ${pattern.id}: ${pattern.title}`)\n    lines.push('')\n    lines.push(pattern.summary)\n    lines.push('')\n  }\n\n  // Guarantees\n  lines.push('## Canon Guarantees')\n  lines.push('')\n  lines.push('Following these patterns provides these guarantees:')\n  lines.push('')\n\n  for (const guarantee of guarantees) {\n    lines.push(`- **${guarantee.name}** (${guarantee.id}): Patterns ${guarantee.patterns.join(', ')}`)\n  }\n  lines.push('')\n\n  // Quick reference for components\n  lines.push('## Component Quick Reference')\n  lines.push('')\n  lines.push('### Typography')\n  lines.push('- `Heading` - props: `as`, `color`, `margin`, `fontSize`, `fontWeight`, `textAlign`')\n  lines.push('- `Paragraph` - props: `color`, `margin`, `fontSize`, `lineHeight`, `textAlign`')\n  lines.push('- `Span` - props: `color`, `margin`, `fontSize` (inline text, mb-0 default)')\n  lines.push('- `Label` - props: `color`, `margin`, `fontSize`, `fontWeight`, `textAlign`')\n  lines.push('')\n  lines.push('### Layout')\n  lines.push('- `Section` - semantic section wrapper')\n  lines.push('- `Columns` - grid layout, props: `cols`, `gap`, `align`')\n  lines.push('- `Column` - column child')\n  lines.push('')\n  lines.push('### Interactive')\n  lines.push('- `Button` - props: `href`, `variant`, `icon`, `iconPlacement`, `margin`')\n  lines.push('- `Icon` - Iconify icon wrapper')\n  lines.push('')\n\n  // Do NOT section\n  lines.push('## Do NOT')\n  lines.push('')\n  lines.push('- Use `\\'use client\\'` in blocks - extract to components')\n  lines.push('- Use raw `<p>` or `<span>` - use Paragraph/Span components')\n  lines.push('- Use className for margin/color/fontSize when component has props')\n  lines.push('- Use Container inside Section - Section already provides containment')\n  lines.push('- Use `classnames` package - use `clsx` instead')\n  lines.push('- Use inline styles for hover states - use Tailwind classes')\n  lines.push('')\n\n  // Post-edit verification\n  lines.push('## Post-Edit Verification')\n  lines.push('')\n  lines.push('After editing files:')\n  lines.push('1. Run `npm run lint` to check for errors')\n  lines.push('2. Fix any violations before committing')\n  lines.push('')\n  lines.push('Note: Only lint files you edited, not the entire codebase.')\n  lines.push('')\n\n  return lines.join('\\n')\n}\n\nexport async function generate(options: GenerateOptions): Promise<void> {\n  const content = generateCursorrules()\n\n  if (options.output === '-') {\n    // Output to stdout\n    console.log(content)\n  } else {\n    // Write to file\n    const outputPath = path.resolve(process.cwd(), options.output)\n    fs.writeFileSync(outputPath, content, 'utf-8')\n    console.log(`✓ Generated ${options.output} from Canon v${version}`)\n    console.log(`  ${patterns.length} patterns, ${guarantees.length} guarantees`)\n  }\n}\n"]}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import { audit } from './commands/audit.js';
+import { generate } from './commands/generate.js';
+import { version } from '../index.js';
+const args = process.argv.slice(2);
+const command = args[0];
+// Colors for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+};
+function showHelp() {
+    console.log(`
+${colors.bold}Gallop CLI${colors.reset} - Canon Compliance Tooling
+${colors.dim}Canon Version: ${version}${colors.reset}
+
+${colors.bold}Usage:${colors.reset}
+  gallop <command> [options]
+
+${colors.bold}Commands:${colors.reset}
+  audit [path]       Check Canon compliance (default: src/blocks/)
+  generate [output]  Generate AI rules from Canon (default: .cursorrules)
+  version            Show version information
+  help               Show this help message
+
+${colors.bold}Audit Options:${colors.reset}
+  --strict           Exit with error code on violations
+  --json             Output as JSON
+
+${colors.bold}Generate Options:${colors.reset}
+  --output, -o       Output file path (default: .cursorrules)
+
+${colors.bold}Examples:${colors.reset}
+  gallop audit
+  gallop audit src/blocks/ --strict
+  gallop generate
+  gallop generate .cursorrules
+  gallop generate --output .github/copilot-instructions.md
+`);
+}
+function showVersion() {
+    console.log(`Gallop CLI v1.0.0`);
+    console.log(`Canon v${version}`);
+}
+async function main() {
+    switch (command) {
+        case 'audit':
+            const auditPath = args[1] && !args[1].startsWith('--') ? args[1] : 'src/blocks/';
+            const auditOptions = {
+                strict: args.includes('--strict'),
+                json: args.includes('--json'),
+                fix: args.includes('--fix'),
+            };
+            await audit(auditPath, auditOptions);
+            break;
+        case 'generate':
+            // Find output path from args
+            let outputPath = '.cursorrules';
+            const outputIndex = args.indexOf('--output');
+            const outputIndexShort = args.indexOf('-o');
+            if (outputIndex !== -1 && args[outputIndex + 1]) {
+                outputPath = args[outputIndex + 1];
+            }
+            else if (outputIndexShort !== -1 && args[outputIndexShort + 1]) {
+                outputPath = args[outputIndexShort + 1];
+            }
+            else if (args[1] && !args[1].startsWith('--')) {
+                outputPath = args[1];
+            }
+            const generateOptions = {
+                output: outputPath,
+                format: 'cursorrules',
+            };
+            await generate(generateOptions);
+            break;
+        case 'version':
+        case '-v':
+        case '--version':
+            showVersion();
+            break;
+        case 'help':
+        case '-h':
+        case '--help':
+        case undefined:
+            showHelp();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.error(`Run 'gallop help' for usage information.`);
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/eslint/configs/recommended.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Recommended configuration
+ * A sensible default for any Gallop-based template
+ */
+declare const recommendedConfig: {
+    plugins: string[];
+    rules: {
+        'gallop/no-client-blocks': string;
+        'gallop/no-container-in-section': string;
+        'gallop/prefer-component-props': string;
+    };
+};
+export default recommendedConfig;

package/dist/eslint/configs/recommended.js

@@ -0,0 +1,15 @@
+/**
+ * Recommended configuration
+ * A sensible default for any Gallop-based template
+ */
+const recommendedConfig = {
+    plugins: ['gallop'],
+    rules: {
+        // Core rules that apply to most templates
+        'gallop/no-client-blocks': 'warn',
+        'gallop/no-container-in-section': 'warn',
+        'gallop/prefer-component-props': 'warn',
+    },
+};
+export default recommendedConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb21tZW5kZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXNsaW50L2NvbmZpZ3MvcmVjb21tZW5kZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRztJQUN4QixPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDbkIsS0FBSyxFQUFFO1FBQ0wsMENBQTBDO1FBQzFDLHlCQUF5QixFQUFFLE1BQU07UUFDakMsZ0NBQWdDLEVBQUUsTUFBTTtRQUN4QywrQkFBK0IsRUFBRSxNQUFNO0tBQ3hDO0NBQ0YsQ0FBQTtBQUVELGVBQWUsaUJBQWlCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJlY29tbWVuZGVkIGNvbmZpZ3VyYXRpb25cbiAqIEEgc2Vuc2libGUgZGVmYXVsdCBmb3IgYW55IEdhbGxvcC1iYXNlZCB0ZW1wbGF0ZVxuICovXG5jb25zdCByZWNvbW1lbmRlZENvbmZpZyA9IHtcbiAgcGx1Z2luczogWydnYWxsb3AnXSxcbiAgcnVsZXM6IHtcbiAgICAvLyBDb3JlIHJ1bGVzIHRoYXQgYXBwbHkgdG8gbW9zdCB0ZW1wbGF0ZXNcbiAgICAnZ2FsbG9wL25vLWNsaWVudC1ibG9ja3MnOiAnd2FybicsXG4gICAgJ2dhbGxvcC9uby1jb250YWluZXItaW4tc2VjdGlvbic6ICd3YXJuJyxcbiAgICAnZ2FsbG9wL3ByZWZlci1jb21wb25lbnQtcHJvcHMnOiAnd2FybicsXG4gIH0sXG59XG5cbmV4cG9ydCBkZWZhdWx0IHJlY29tbWVuZGVkQ29uZmlnXG4iXX0=

package/dist/eslint/configs/speedwell.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Speedwell template configuration
+ * Enables all Gallop rules relevant to the Speedwell architecture
+ */
+declare const speedwellConfig: {
+    plugins: string[];
+    rules: {
+        'gallop/no-client-blocks': string;
+        'gallop/no-container-in-section': string;
+        'gallop/prefer-component-props': string;
+    };
+};
+export default speedwellConfig;

package/dist/eslint/configs/speedwell.js

@@ -0,0 +1,17 @@
+/**
+ * Speedwell template configuration
+ * Enables all Gallop rules relevant to the Speedwell architecture
+ */
+const speedwellConfig = {
+    plugins: ['gallop'],
+    rules: {
+        // Blocks should be server components - extract client logic to components
+        'gallop/no-client-blocks': 'warn',
+        // Section already provides containment
+        'gallop/no-container-in-section': 'warn',
+        // Use component props instead of className for style values
+        'gallop/prefer-component-props': 'warn',
+    },
+};
+export default speedwellConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlZWR3ZWxsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VzbGludC9jb25maWdzL3NwZWVkd2VsbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLGVBQWUsR0FBRztJQUN0QixPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDbkIsS0FBSyxFQUFFO1FBQ0wsMEVBQTBFO1FBQzFFLHlCQUF5QixFQUFFLE1BQU07UUFFakMsdUNBQXVDO1FBQ3ZDLGdDQUFnQyxFQUFFLE1BQU07UUFFeEMsNERBQTREO1FBQzVELCtCQUErQixFQUFFLE1BQU07S0FDeEM7Q0FDRixDQUFBO0FBRUQsZUFBZSxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNwZWVkd2VsbCB0ZW1wbGF0ZSBjb25maWd1cmF0aW9uXG4gKiBFbmFibGVzIGFsbCBHYWxsb3AgcnVsZXMgcmVsZXZhbnQgdG8gdGhlIFNwZWVkd2VsbCBhcmNoaXRlY3R1cmVcbiAqL1xuY29uc3Qgc3BlZWR3ZWxsQ29uZmlnID0ge1xuICBwbHVnaW5zOiBbJ2dhbGxvcCddLFxuICBydWxlczoge1xuICAgIC8vIEJsb2NrcyBzaG91bGQgYmUgc2VydmVyIGNvbXBvbmVudHMgLSBleHRyYWN0IGNsaWVudCBsb2dpYyB0byBjb21wb25lbnRzXG4gICAgJ2dhbGxvcC9uby1jbGllbnQtYmxvY2tzJzogJ3dhcm4nLFxuXG4gICAgLy8gU2VjdGlvbiBhbHJlYWR5IHByb3ZpZGVzIGNvbnRhaW5tZW50XG4gICAgJ2dhbGxvcC9uby1jb250YWluZXItaW4tc2VjdGlvbic6ICd3YXJuJyxcblxuICAgIC8vIFVzZSBjb21wb25lbnQgcHJvcHMgaW5zdGVhZCBvZiBjbGFzc05hbWUgZm9yIHN0eWxlIHZhbHVlc1xuICAgICdnYWxsb3AvcHJlZmVyLWNvbXBvbmVudC1wcm9wcyc6ICd3YXJuJyxcbiAgfSxcbn1cblxuZXhwb3J0IGRlZmF1bHQgc3BlZWR3ZWxsQ29uZmlnXG4iXX0=