@malamute/ai-rules 1.0.0 → 1.3.0

package/configs/nextjs/{.claude/rules → rules}/state/zustand.md

@@ -82,7 +82,7 @@ export const useUserStore = create<UserState>((set) => ({
 
 ```typescript
 // stores/app-store.ts
-import { create } from 'zustand';
+import { create, StateCreator } from 'zustand';
 
 // User slice
 interface UserSlice {
@@ -90,7 +90,7 @@ interface UserSlice {
   setUser: (user: User | null) => void;
 }
 
-const createUserSlice = (set: any): UserSlice => ({
+const createUserSlice: StateCreator<AppStore, [], [], UserSlice> = (set) => ({
   user: null,
   setUser: (user) => set({ user }),
 });
@@ -103,13 +103,13 @@ interface CartSlice {
   clearCart: () => void;
 }
 
-const createCartSlice = (set: any): CartSlice => ({
+const createCartSlice: StateCreator<AppStore, [], [], CartSlice> = (set) => ({
   items: [],
-  addItem: (item) => set((state: any) => ({
+  addItem: (item) => set((state) => ({
     items: [...state.items, item]
   })),
-  removeItem: (id) => set((state: any) => ({
-    items: state.items.filter((item: CartItem) => item.id !== id)
+  removeItem: (id) => set((state) => ({
+    items: state.items.filter((item) => item.id !== id)
   })),
   clearCart: () => set({ items: [] }),
 });

package/configs/nextjs/{.claude/settings.json → settings.json}

@@ -14,16 +14,23 @@
       "Bash(npm install *)",
       "Bash(npm ci)",
       "Bash(npx nx *)",
+      "Bash(npx prisma *)",
       "Read",
       "Edit",
       "Write"
     ],
     "deny": [
+      "Bash(git push *)",
+      "Bash(git push)",
       "Bash(rm -rf *)",
       "Bash(nx reset)",
       "Read(.env)",
       "Read(.env.*)",
       "Read(**/secrets/**)"
     ]
+  },
+  "env": {
+    "NODE_ENV": "development",
+    "NX_DAEMON": "true"
   }
 }

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@malamute/ai-rules",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "Claude Code configuration boilerplates for Angular, Next.js, NestJS, .NET, Python and more",
-  "main": "src/install.js",
-  "bin": {
-    "ai-rules": "./bin/cli.js"
-  },
+  "type": "module",
+  "main": "src/index.js",
+  "bin": "./bin/cli.js",
   "scripts": {
-    "test": "node bin/cli.js --help"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src bin",
+    "lint:rules": "node scripts/lint-rules.js",
+    "validate": "npm test && npm run lint:rules"
   },
   "keywords": [
     "claude",
@@ -24,12 +28,16 @@
     "python",
     "fastapi"
   ],
-  "author": "",
+  "author": "Mehdi Chaabi",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "git+https://github.com/SpaceMalamute/ai-rules.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SpaceMalamute/ai-rules/issues"
   },
+  "homepage": "https://github.com/SpaceMalamute/ai-rules#readme",
   "files": [
     "bin",
     "src",
@@ -37,5 +45,12 @@
   ],
   "engines": {
     "node": ">=18.0.0"
-  }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "eslint": "^9.39.2",
+    "husky": "^9.1.7",
+    "vitest": "^2.0.0"
+  },
+  "packageManager": "yarn@4.12.0"
 }

package/src/cli.js

@@ -0,0 +1,218 @@
+import readline from 'readline';
+import { colors, log } from './utils.js';
+import { VERSION, AVAILABLE_TECHS } from './config.js';
+import { init, update, status, listTechnologies } from './installer.js';
+
+function printUsage() {
+  console.log(`
+${colors.bold('AI Rules')} v${VERSION} - Claude Code configuration boilerplates
+
+${colors.bold('Usage:')}
+  ai-rules init [tech] [tech2] [options]
+  ai-rules update [options]
+  ai-rules status
+  ai-rules list
+
+${colors.bold('Commands:')}
+  init      Install configuration (interactive if no tech specified)
+  update    Update installed configs to latest version
+  status    Show current installation status
+  list      List available technologies
+
+${colors.bold('Technologies:')}
+  angular    Angular 21 + Nx + NgRx
+  nextjs     Next.js 15 + React 19
+  nestjs     NestJS + Prisma/TypeORM
+  dotnet     .NET 9 + EF Core
+  fastapi    FastAPI + SQLAlchemy + Pydantic
+  flask      Flask + SQLAlchemy + Marshmallow
+
+${colors.bold('Options:')}
+  --minimal        Only install CLAUDE.md, settings.json, and tech rules (no shared skills/rules)
+  --target <dir>   Target directory (default: current directory)
+  --dry-run        Preview changes without writing files
+  --force          Overwrite files without backup (update command)
+
+${colors.bold('Examples:')}
+  ai-rules init                          # Interactive mode
+  ai-rules init angular                  # Full install (skills + rules)
+  ai-rules init angular --minimal        # Minimal install
+  ai-rules init nextjs --dry-run
+  ai-rules update
+  ai-rules update --force
+  ai-rules status
+`);
+}
+
+async function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function multiSelect(message, choices) {
+  console.log(`\n${colors.bold(message)}`);
+  console.log(colors.dim('(enter numbers separated by spaces, or "all")'));
+  console.log('');
+
+  choices.forEach((choice, i) => {
+    console.log(`  ${colors.cyan(i + 1)}. ${choice.name} ${colors.dim(`- ${choice.description}`)}`);
+  });
+
+  console.log('');
+  const answer = await prompt('Your selection: ');
+
+  if (answer.toLowerCase() === 'all') {
+    return choices.map((c) => c.value);
+  }
+
+  const indices = answer
+    .split(/[\s,]+/)
+    .map((s) => parseInt(s, 10) - 1)
+    .filter((i) => i >= 0 && i < choices.length);
+
+  return indices.map((i) => choices[i].value);
+}
+
+async function interactiveInit() {
+  console.log(`\n${colors.bold('AI Rules')} - Interactive Setup\n`);
+
+  const techChoices = [
+    { name: 'Angular', value: 'angular', description: 'Angular 21 + Nx + NgRx + Signals' },
+    { name: 'Next.js', value: 'nextjs', description: 'Next.js 15 + React 19 + App Router' },
+    { name: 'NestJS', value: 'nestjs', description: 'NestJS 11 + Prisma/TypeORM + Passport' },
+    { name: '.NET', value: 'dotnet', description: '.NET 9 + ASP.NET Core + EF Core' },
+    { name: 'FastAPI', value: 'fastapi', description: 'FastAPI + SQLAlchemy 2.0 + Pydantic v2' },
+    { name: 'Flask', value: 'flask', description: 'Flask + SQLAlchemy 2.0 + Marshmallow' },
+  ];
+
+  const techs = await multiSelect('Select technologies:', techChoices);
+
+  if (techs.length === 0) {
+    log.error('No technology selected');
+    process.exit(1);
+  }
+
+  const extraChoices = [
+    { name: 'Skills', value: 'skills', description: '/learning, /review, /spec, /debug, etc.' },
+    { name: 'Shared Rules', value: 'rules', description: 'security, performance, accessibility' },
+  ];
+
+  const extras = await multiSelect('Include extras:', extraChoices);
+
+  const targetDir = await prompt(`Target directory ${colors.dim('(. for current)')}: `) || '.';
+
+  const options = {
+    target: targetDir === '.' ? null : targetDir,
+    withSkills: extras.includes('skills'),
+    withRules: extras.includes('rules'),
+    all: false,
+    dryRun: false,
+    force: false,
+  };
+
+  console.log('');
+  return { techs, options };
+}
+
+export async function run(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    printUsage();
+    return;
+  }
+
+  if (args.length === 0) {
+    printUsage();
+    return;
+  }
+
+  const command = args[0];
+
+  if (command === 'list') {
+    listTechnologies();
+    return;
+  }
+
+  if (command === 'status') {
+    const targetIndex = args.indexOf('--target');
+    const targetDir = targetIndex !== -1 ? args[targetIndex + 1] : process.cwd();
+    status(targetDir);
+    return;
+  }
+
+  if (command === 'update') {
+    const options = {
+      target: null,
+      dryRun: args.includes('--dry-run'),
+      force: args.includes('--force'),
+    };
+
+    const targetIndex = args.indexOf('--target');
+    if (targetIndex !== -1) {
+      options.target = args[targetIndex + 1];
+    }
+
+    await update(options);
+    return;
+  }
+
+  if (command === 'init') {
+    const minimal = args.includes('--minimal');
+    const options = {
+      target: null,
+      withSkills: !minimal,
+      withRules: !minimal,
+      dryRun: args.includes('--dry-run'),
+      force: args.includes('--force'),
+    };
+
+    const techs = [];
+
+    for (let i = 1; i < args.length; i++) {
+      const arg = args[i];
+
+      if (arg === '--minimal') {
+        // Already handled above
+      } else if (arg === '--target') {
+        options.target = args[++i];
+      } else if (arg === '--dry-run' || arg === '--force') {
+        // Already handled
+      } else if (!arg.startsWith('-')) {
+        if (AVAILABLE_TECHS.includes(arg)) {
+          techs.push(arg);
+        } else {
+          log.error(`Unknown technology: ${arg}`);
+          console.log(`Available: ${AVAILABLE_TECHS.join(', ')}`);
+          process.exit(1);
+        }
+      }
+    }
+
+    // Interactive mode if no techs specified
+    if (techs.length === 0) {
+      try {
+        const result = await interactiveInit();
+        init(result.techs, { ...options, ...result.options });
+      } catch (_e) {
+        console.log('\nAborted.');
+        process.exit(0);
+      }
+      return;
+    }
+
+    init(techs, options);
+    return;
+  }
+
+  log.error(`Unknown command: ${command}`);
+  printUsage();
+  process.exit(1);
+}

package/src/config.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const require = createRequire(import.meta.url);
+
+export const CONFIGS_DIR = path.join(__dirname, '..', 'configs');
+export const AVAILABLE_TECHS = ['angular', 'nextjs', 'nestjs', 'dotnet', 'fastapi', 'flask'];
+export const VERSION = require('../package.json').version;
+
+export const TECH_CONFIG = JSON.parse(
+  fs.readFileSync(path.join(__dirname, 'tech-config.json'), 'utf8')
+);
+
+/**
+ * Get rule directories to include based on selected technologies.
+ * Returns paths relative to the rules directory (e.g., "lang/typescript", "domain/frontend").
+ */
+export function getRulePathsToInclude(techs) {
+  const paths = new Set();
+  const { ruleMapping, alwaysInclude } = TECH_CONFIG;
+
+  // Always include common rules
+  alwaysInclude.forEach((dir) => paths.add(dir));
+
+  // Add language and domain-specific rules based on selected techs
+  for (const tech of techs) {
+    const config = TECH_CONFIG.technologies[tech];
+    if (!config) continue;
+
+    // Add language-specific rules (e.g., "lang/typescript")
+    if (config.language && ruleMapping.language[config.language]) {
+      paths.add(ruleMapping.language[config.language]);
+    }
+
+    // Add domain-specific rules (e.g., "domain/frontend")
+    if (config.type && ruleMapping.type[config.type]) {
+      paths.add(ruleMapping.type[config.type]);
+    }
+  }
+
+  return paths;
+}
+
+/**
+ * Check if a rule path should be included for the given technologies.
+ * @param {string} rulePath - Path relative to rules dir (e.g., "lang/python/async.md")
+ * @param {Set<string>} includedPaths - Set of paths to include
+ * @returns {boolean}
+ */
+export function shouldIncludeRule(rulePath, includedPaths) {
+  // Check if the path starts with any of the included paths
+  for (const includedPath of includedPaths) {
+    if (rulePath === includedPath || rulePath.startsWith(includedPath + '/')) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export { run } from './cli.js';
+export { init, update, status } from './installer.js';
+export { readManifest } from './merge.js';
+export { VERSION } from './config.js';