@shahmilsaari/memory-core 1.0.27 → 1.0.29

package/README.md

@@ -2,128 +2,123 @@
 
 > Universal AI memory for developers. Store architecture rules once — every AI coding agent reads them before writing code.
 
-[![npm](https://img.shields.io/npm/v/@shahmilsaari/memory-core)](https://www.npmjs.com/package/@shahmilsaari/memory-core)
+[![npm version](https://img.shields.io/npm/v/@shahmilsaari/memory-core)](https://www.npmjs.com/package/@shahmilsaari/memory-core)
+[![npm downloads](https://img.shields.io/npm/dm/@shahmilsaari/memory-core)](https://www.npmjs.com/package/@shahmilsaari/memory-core)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
 ---
 
-## What it does
+## The problem
+
+AI tools like Copilot, Cursor, and Claude Code start fresh every session. They don't know your architecture decisions, your layer boundaries, or your team conventions. They write code that violates patterns you spent months establishing.
+
+**memory-core fixes that.** Store your rules once, enforce them everywhere.
+
+---
 
-AI tools like Copilot, Cursor, and Claude Code start fresh every session. memory-core fixes that:
+## What it does
 
-1. **Remember** — store architecture decisions and rules in PostgreSQL with reasons
-2. **Distribute** — generate instruction files for 14 AI agents from your stored rules
-3. **Enforce** — two-tier pipeline catches violations: deterministic layer graph (instant, confidence 1.0) then AI semantic review
+1. **Remember** — store architecture decisions and rules in PostgreSQL with plain-English reasons
+2. **Distribute** — generate instruction files for 14 AI agents automatically from your stored rules
+3. **Enforce** — two-tier pipeline catches violations before they merge: deterministic layer graph (instant, confidence 1.0) then AI semantic review
 
 ```bash
 npx @shahmilsaari/memory-core init
 ```
 
-## Quick start
+---
+
+## Key features
+
+- **281 pre-built rules** — seed best-practice rules for your stack in one command, with plain-English reasons
+- **14 AI agents supported** — generates instruction files for Copilot, Cursor, Claude Code, Windsurf, and more automatically
+- **Evidence-based enforcement** — catches layer violations deterministically before touching AI, then uses semantic review for the rest
+- **Runs fully local** — embeddings stay on your machine via Ollama; use any cloud provider (DeepSeek, OpenAI, Anthropic) only for code analysis
+- **Live dashboard** — real-time violations feed, interactive architecture graph, and model switcher at `localhost:5178`
+- **Team-ready** — export rules to `memories.json`, commit it, and teammates import with one command — no shared database needed
+- **CI/CD built-in** — generates a GitHub Actions workflow; CI reads `memories.json` directly, no Ollama required
+- **Commit message linting** — enforce conventional commits or any regex pattern via the `commit-msg` hook
+- **Violation analytics** — track which rules fire most and auto-tune noisy ones with `memory-core tune`
+- **Pre-commit hook** — advisory or strict mode; bypass anytime with `MEMORY_CORE_SKIP_HOOK=1`
+
+---
+
+## Get started
+
+**Requires:** Node.js ≥ 18, PostgreSQL 14+, [Ollama](https://ollama.com) with `nomic-embed-text`
 
 ```bash
 # 1. Initialize in your project
 npx @shahmilsaari/memory-core init
 
-# 2. Load best-practice rules for your architecture
+# 2. Load best-practice rules for your stack
 memory-core seed --arch clean-architecture
 
-# 3. Store a project decision
+# 3. Store your own decisions
 memory-core remember "No direct DB calls from controllers"
 
-# 4. Enforce on every diff
-memory-core check --diff HEAD~1
-```
-
-## Architecture enforcement
-
-The `check --diff` command runs a two-tier enforcement pipeline:
-
-```
-git diff → FileClassifier → ASTAnalyzer → GraphBuilder
-         → RuleMatcher → EvidencePacketBuilder
-         → graphEngine (full codebase graph)
-         → DeterministicValidator (confidence 1.0)
-         → AI judge (OllamaJudge / DeepSeek / OpenAI-compatible)
-         → ConfidenceGate → allow | warn | block
+# 4. Enforce on every commit
+memory-core hook install
 ```
 
-Configure your layers in `.archmind/layers.json` and rules in `.archmind/rules.json`. The dashboard shows a live layer graph SVG updated in real time as rules change.
+That's it. Every AI agent in your project now reads your rules before writing code.
 
-Built-in production hardening: rate limiter prevents concurrent AI calls, content-addressed cache skips redundant checks, auto graph build has a 15s timeout so hooks never hang, and all check results are logged as structured JSON to `.archmind/check.log`.
-
-## Installation requirements
+---
 
-| Dependency | Purpose | Install |
-|---|---|---|
-| Node.js 18+ | Runtime | — |
-| PostgreSQL 14+ | Rules storage | `brew install postgresql@16` |
-| pgvector | Semantic search | `brew install pgvector` |
-| Ollama | Local embeddings | `ollama pull nomic-embed-text` |
+## Supported agents
 
-Cloud providers (OpenAI, Anthropic, DeepSeek, any OpenAI-compatible endpoint) can be used for code analysis — embeddings always stay local.
+Claude Code · GitHub Copilot · Cursor · Windsurf · Cline · Roo Code · Aider · Continue.dev · Devin · Amazon Q · Gemini Code Assist · Zed AI · JetBrains AI · OpenHands
 
-## Supported AI agents
+---
 
-Claude Code · GitHub Copilot · Cursor · Windsurf · Cline · Roo Code · Aider · Continue.dev · Devin · Amazon Q · Gemini Code Assist · Zed AI · JetBrains AI · OpenHands
+## Architecture profiles
 
-## Key commands
+281 pre-built rules ready to load:
 
-| Command | Description |
-|---|---|
-| `memory-core init` | Set up memory-core in the current project |
-| `memory-core remember "..."` | Store an architecture decision |
-| `memory-core check --diff <ref>` | Evidence-based arch enforcement against a git ref |
-| `memory-core check --staged` | Check staged diff (pre-commit hook path) |
-| `memory-core watch --auto-fix` | Real-time violation detection with AI auto-fix |
-| `memory-core dashboard` | Live command center at `localhost:5178` |
-| `memory-core graph build` | Snapshot full codebase dependency graph |
-| `memory-core seed` | Load 281 best-practice rules |
-| `memory-core sync` | Regenerate all agent instruction files |
-| `memory-core export` | Export rules to `memories.json` for team sharing |
+`clean-architecture` · `nestjs` · `react` · `svelte` · `vue` · `hexagonal` · `modular-monolith` · `mvc` · `laravel-service-repository` · `nuxt` · `angular` · `go-api` · `react-native`
 
-See [COMMANDS.md](COMMANDS.md) for the full reference.
+---
 
-## Dashboard
+## Commands
 
 ```bash
-memory-core dashboard
+memory-core remember "..."        # store a rule or decision
+memory-core sync                  # push rules to all AI agent files
+memory-core check --diff HEAD~1   # enforce architecture on a diff
+memory-core watch                 # real-time violation detection
+memory-core dashboard             # live command center at localhost:5178
+memory-core export                # share rules with your team via memories.json
+memory-core stats                 # see which rules fire most
 ```
 
-Opens at `http://localhost:5178`. Shows:
-- Live violations feed via WebSocket
-- Layer graph — interactive SVG of your architecture topology
-- Model switcher — change provider/model without restart
-- Token usage — Ollama shows "LOCAL (FREE)", paid providers show real counts
-- Actions panel — Sync Agents, Check All without opening a terminal
+→ [Full command reference](COMMANDS.md)
+
+---
 
 ## Environment
 
 ```env
-# PostgreSQL
-DATABASE_URL=postgres://localhost:5432/memory_core
-
-# Ollama (local, for embeddings)
+DATABASE_URL=postgresql://localhost:5432/memory_core
 OLLAMA_URL=http://localhost:11434
 OLLAMA_MODEL=nomic-embed-text
 
-# AI provider for code analysis (choose one)
-CHAT_PROVIDER=ollama
-CHAT_MODEL=qwen2.5-coder:7b
-
-# OpenAI-compatible (e.g. DeepSeek)
+# Pick your AI provider for code analysis
 CHAT_PROVIDER=openai-compatible
-CHAT_BASE_URL=https://api.deepseek.com/v1
+CHAT_BASE_URL=https://api.deepseek.com
 CHAT_MODEL=deepseek-chat
 CHAT_API_KEY=sk-...
 ```
 
-## Docs
+---
+
+## Links
 
+- [Website](https://memory-core.shahmilsaari.my/)
 - [Commands reference](COMMANDS.md)
-- [Dashboard](docs/dashboard.md)
-- [Technical design](TECHNICAL_DESIGN.md)
-- [Website](https://shahmilsaari.github.io/memory-core/)
+- [Dashboard guide](docs/dashboard.md)
+
+---
 
 ## License
 

package/dist/cli.js

@@ -1074,7 +1074,8 @@ program.command("init").description("Initialize memory-core in the current proje
       console.log(chalk.green("  \u2713 Created .archmind/layers.json"));
     }
     if (!existsSync(rulesPath)) {
-      writeFileSync(rulesPath, JSON.stringify(DEFAULT_ARCH_RULES, null, 2) + "\n", "utf-8");
+      const arch2 = backendArchitecture ?? frontendFramework ?? "custom";
+      writeFileSync(rulesPath, JSON.stringify(buildArchRules(arch2), null, 2) + "\n", "utf-8");
       console.log(chalk.green("  \u2713 Created .archmind/rules.json"));
     }
     if (!existsSync(archmindGitignorePath)) {
@@ -1752,7 +1753,7 @@ program.command("dashboard").description("Start the live Svelte dashboard with W
     }
     return void 0;
   };
-  const { startDashboard } = await import("./dashboard-server-TWLZQE2J.js");
+  const { startDashboard } = await import("./dashboard-server-DHSVWCCD.js");
   await startDashboard({
     port: parseInt(opts.port, 10),
     path: resolveDashboardPath(),
@@ -1802,6 +1803,19 @@ program.command("seed").description("Load all predefined memories into the datab
     const dbVersionPath = join(process.cwd(), ".memory-core-db-version");
     writeFileSync(dbVersionPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
   }
+  if (opts.arch) {
+    try {
+      const archmindDir = join(process.cwd(), ".archmind");
+      mkdirSync(archmindDir, { recursive: true });
+      const layersPath = join(archmindDir, "layers.json");
+      const rulesPath = join(archmindDir, "rules.json");
+      writeFileSync(layersPath, JSON.stringify(buildLayersTemplate(opts.arch), null, 2) + "\n", "utf-8");
+      writeFileSync(rulesPath, JSON.stringify(buildArchRules(opts.arch), null, 2) + "\n", "utf-8");
+      console.log(chalk.green(`  \u2713 Updated .archmind/layers.json for ${opts.arch}`));
+      console.log(chalk.green(`  \u2713 Updated .archmind/rules.json for ${opts.arch}`));
+    } catch {
+    }
+  }
   console.log(chalk.bold.green(`
   Done. ${saved} memories seeded, ${skipped} skipped.
 `));
@@ -2561,51 +2575,225 @@ program.command("watch").description("Watch source files and check violations in
   });
 });
 var ARCHMIND_DIR = join(process.cwd(), ".archmind");
-var DEFAULT_ARCH_RULES = {
-  rules: [
-    { id: "domain-no-infra", name: "Domain must not import infrastructure", fromLayer: "domain", toLayer: "infrastructure", allowed: false, severity: "critical", enforcement: "block" },
-    { id: "domain-no-api", name: "Domain must not import API layer", fromLayer: "domain", toLayer: "api", allowed: false, severity: "critical", enforcement: "block" },
-    { id: "api-no-infra-direct", name: "API should not import infrastructure directly", fromLayer: "api", toLayer: "infrastructure", allowed: false, severity: "medium", enforcement: "warn" },
-    { id: "api-depends-on-domain", name: "API depends on domain", fromLayer: "api", toLayer: "domain", allowed: true, severity: "low", enforcement: "suggest" },
-    { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
-    { id: "application-no-api", name: "Application must not import API layer", fromLayer: "application", toLayer: "api", allowed: false, severity: "critical", enforcement: "block" },
-    { id: "application-uses-domain", name: "Application depends on domain", fromLayer: "application", toLayer: "domain", allowed: true, severity: "low", enforcement: "suggest" },
-    { id: "shared-no-domain", name: "Shared must not import domain", fromLayer: "shared", toLayer: "domain", allowed: false, severity: "medium", enforcement: "warn" }
-  ]
-};
 function buildLayersTemplate(arch2) {
-  const mvc = ["nestjs", "mvc", "laravel", "go-api"].includes(arch2);
-  const frontend = ["react", "vue", "angular", "svelte", "nuxt", "react-native"].includes(arch2);
-  if (frontend) {
-    return {
-      layers: [
-        { name: "domain", paths: ["src/domain/**", "src/store/**", "src/state/**"], description: "State, models, business logic" },
-        { name: "application", paths: ["src/services/**", "src/hooks/**", "src/composables/**"], description: "App services and hooks" },
-        { name: "infrastructure", paths: ["src/api/**", "src/lib/**", "src/clients/**"], description: "External API clients, adapters" },
-        { name: "shared", paths: ["src/utils/**", "src/helpers/**", "src/constants/**"], description: "Shared utilities" }
-      ]
-    };
+  switch (arch2) {
+    case "nestjs":
+      return {
+        layers: [
+          { name: "modules", paths: ["src/modules/**"], description: "Feature modules \u2014 each owns its controller, service, DTOs, entities" },
+          { name: "controllers", paths: ["src/modules/*/controllers/**", "src/modules/*.controller.ts"], description: "HTTP request handlers \u2014 thin, delegate to services" },
+          { name: "services", paths: ["src/modules/*/services/**", "src/modules/*.service.ts"], description: "Business logic \u2014 never import controllers or HTTP classes" },
+          { name: "repositories", paths: ["src/modules/*/repositories/**"], description: "Data access \u2014 services depend on these interfaces" },
+          { name: "common", paths: ["src/common/**", "src/guards/**", "src/filters/**", "src/interceptors/**", "src/pipes/**"], description: "Guards, filters, interceptors, pipes" }
+        ]
+      };
+    case "mvc":
+      return {
+        layers: [
+          { name: "models", paths: ["src/models/**", "app/models/**"], description: "Data models \u2014 represent DB records" },
+          { name: "controllers", paths: ["src/controllers/**", "app/controllers/**"], description: "Route handlers \u2014 thin, delegate to services" },
+          { name: "services", paths: ["src/services/**", "app/services/**"], description: "Business logic \u2014 called by controllers" },
+          { name: "views", paths: ["src/views/**", "app/views/**", "resources/views/**"], description: "Templates and view logic" },
+          { name: "shared", paths: ["src/utils/**", "src/helpers/**", "app/helpers/**"], description: "Shared utilities and helpers" }
+        ]
+      };
+    case "laravel-service-repository":
+      return {
+        layers: [
+          { name: "models", paths: ["app/Models/**"], description: "Eloquent models" },
+          { name: "controllers", paths: ["app/Http/Controllers/**"], description: "HTTP controllers \u2014 thin, delegate to services" },
+          { name: "services", paths: ["app/Services/**"], description: "Business logic services" },
+          { name: "repositories", paths: ["app/Repositories/**"], description: "Data access \u2014 services depend on these" },
+          { name: "shared", paths: ["app/Helpers/**", "app/Traits/**"], description: "Helpers and traits" }
+        ]
+      };
+    case "go-api":
+      return {
+        layers: [
+          { name: "handlers", paths: ["internal/handlers/**", "api/**"], description: "HTTP handlers \u2014 parse request, call service, write response" },
+          { name: "services", paths: ["internal/services/**"], description: "Business logic \u2014 orchestrates domain and repositories" },
+          { name: "repositories", paths: ["internal/repositories/**", "internal/store/**"], description: "Data access \u2014 DB queries, external calls" },
+          { name: "models", paths: ["internal/models/**", "internal/domain/**"], description: "Structs and domain types" },
+          { name: "shared", paths: ["pkg/**", "internal/utils/**"], description: "Shared packages \u2014 no business logic" }
+        ]
+      };
+    case "react":
+      return {
+        layers: [
+          { name: "pages", paths: ["src/pages/**", "src/app/**", "src/routes/**"], description: "Route-level components \u2014 wire hooks and components together" },
+          { name: "components", paths: ["src/components/**"], description: "Reusable UI components \u2014 presentational and feature" },
+          { name: "hooks", paths: ["src/hooks/**"], description: "Custom hooks \u2014 stateful and side-effect logic" },
+          { name: "store", paths: ["src/store/**", "src/state/**", "src/atoms/**"], description: "Global client state \u2014 Zustand, Jotai, Redux" },
+          { name: "services", paths: ["src/services/**", "src/api/**", "src/clients/**"], description: "API clients and external service calls" }
+        ]
+      };
+    case "vue":
+      return {
+        layers: [
+          { name: "pages", paths: ["src/pages/**", "src/views/**"], description: "Route-level views" },
+          { name: "components", paths: ["src/components/**"], description: "Reusable Vue components" },
+          { name: "composables", paths: ["src/composables/**"], description: "Composables \u2014 stateful and reusable logic" },
+          { name: "store", paths: ["src/stores/**", "src/store/**"], description: "Pinia stores \u2014 global state" },
+          { name: "services", paths: ["src/services/**", "src/api/**"], description: "API clients and external calls" }
+        ]
+      };
+    case "svelte":
+      return {
+        layers: [
+          { name: "routes", paths: ["src/routes/**"], description: "SvelteKit routes \u2014 pages and layouts" },
+          { name: "components", paths: ["src/lib/components/**", "src/components/**"], description: "Reusable Svelte components" },
+          { name: "stores", paths: ["src/lib/stores/**", "src/stores/**"], description: "Svelte stores \u2014 reactive state" },
+          { name: "lib", paths: ["src/lib/**"], description: "Shared utilities, server actions, API clients" },
+          { name: "utils", paths: ["src/utils/**", "src/helpers/**"], description: "Pure utility functions" }
+        ]
+      };
+    case "nuxt":
+      return {
+        layers: [
+          { name: "pages", paths: ["pages/**"], description: "Nuxt pages \u2014 file-based routing" },
+          { name: "components", paths: ["components/**"], description: "Auto-imported Vue components" },
+          { name: "composables", paths: ["composables/**"], description: "Auto-imported composables" },
+          { name: "server", paths: ["server/**"], description: "Nitro server routes and API" },
+          { name: "utils", paths: ["utils/**", "lib/**"], description: "Shared utilities" }
+        ]
+      };
+    case "angular":
+      return {
+        layers: [
+          { name: "modules", paths: ["src/app/**/*.module.ts"], description: "Angular feature modules" },
+          { name: "components", paths: ["src/app/**/*.component.ts"], description: "Components \u2014 UI logic only" },
+          { name: "services", paths: ["src/app/**/*.service.ts"], description: "Injectable services \u2014 business logic and HTTP" },
+          { name: "guards", paths: ["src/app/**/*.guard.ts"], description: "Route guards \u2014 auth and access control" },
+          { name: "shared", paths: ["src/app/shared/**", "src/shared/**"], description: "Shared module \u2014 directives, pipes, components" }
+        ]
+      };
+    case "react-native":
+      return {
+        layers: [
+          { name: "screens", paths: ["src/screens/**", "app/**"], description: "Screen components \u2014 navigation targets" },
+          { name: "components", paths: ["src/components/**"], description: "Reusable UI components" },
+          { name: "hooks", paths: ["src/hooks/**"], description: "Custom hooks \u2014 stateful logic" },
+          { name: "store", paths: ["src/store/**", "src/state/**"], description: "Global state \u2014 Zustand, Redux, Jotai" },
+          { name: "services", paths: ["src/services/**", "src/api/**"], description: "API clients and native service wrappers" }
+        ]
+      };
+    case "hexagonal":
+      return {
+        layers: [
+          { name: "domain", paths: ["src/domain/**", "src/core/**"], description: "Pure domain \u2014 entities, value objects, domain services" },
+          { name: "ports", paths: ["src/ports/**", "src/application/ports/**"], description: "Interfaces \u2014 driving and driven port contracts" },
+          { name: "adapters", paths: ["src/adapters/**", "src/infrastructure/adapters/**"], description: "Adapter implementations \u2014 REST, DB, queues" },
+          { name: "infrastructure", paths: ["src/infrastructure/**"], description: "Technical infrastructure \u2014 config, DI, framework" },
+          { name: "shared", paths: ["src/shared/**", "src/utils/**"], description: "Cross-cutting utilities" }
+        ]
+      };
+    case "modular-monolith":
+      return {
+        layers: [
+          { name: "modules", paths: ["src/modules/**"], description: "Self-contained feature modules \u2014 each owns its DB, API, logic" },
+          { name: "shared", paths: ["src/shared/**", "src/common/**"], description: "Shared kernel \u2014 only pure utilities, no module business logic" },
+          { name: "infrastructure", paths: ["src/infrastructure/**"], description: "Technical infrastructure \u2014 DB connections, messaging, config" },
+          { name: "api", paths: ["src/api/**", "src/interfaces/**"], description: "Public API surface \u2014 HTTP, GraphQL, events" }
+        ]
+      };
+    default:
+      return {
+        layers: [
+          { name: "domain", paths: ["src/domain/**", "src/core/domain/**", "src/modules/*/domain/**"], description: "Business logic, entities, use cases" },
+          { name: "application", paths: ["src/application/**", "src/core/application/**", "src/modules/*/application/**"], description: "Use cases and orchestration" },
+          { name: "infrastructure", paths: ["src/infrastructure/**", "src/modules/*/infrastructure/**"], description: "Database, external APIs, low-level I/O" },
+          { name: "api", paths: ["src/api/**", "src/interfaces/**", "src/controllers/**"], description: "HTTP handlers, request/response" },
+          { name: "shared", paths: ["src/shared/**", "src/utils/**", "src/helpers/**"], description: "Utilities, helpers, constants" }
+        ]
+      };
   }
-  if (mvc) {
-    return {
-      layers: [
-        { name: "domain", paths: ["src/models/**", "src/entities/**"], description: "Data models and entities" },
-        { name: "application", paths: ["src/services/**"], description: "Business logic services" },
-        { name: "infrastructure", paths: ["src/repositories/**", "src/database/**", "src/infrastructure/**"], description: "DB, external APIs" },
-        { name: "api", paths: ["src/controllers/**", "src/routes/**", "src/handlers/**"], description: "HTTP handlers" },
-        { name: "shared", paths: ["src/utils/**", "src/helpers/**", "src/shared/**"], description: "Shared utilities" }
-      ]
-    };
+}
+function buildArchRules(arch2) {
+  switch (arch2) {
+    case "nestjs":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "controllers-no-repos", name: "Controllers must not import repositories", fromLayer: "controllers", toLayer: "repositories", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "services-no-controllers", name: "Services must not import controllers", fromLayer: "services", toLayer: "controllers", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "controllers-use-services", name: "Controllers delegate to services", fromLayer: "controllers", toLayer: "services", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "services-use-repos", name: "Services use repositories", fromLayer: "services", toLayer: "repositories", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "common-no-modules", name: "Common must not import feature modules", fromLayer: "common", toLayer: "modules", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
+    case "mvc":
+    case "laravel-service-repository":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "controllers-no-models", name: "Controllers must not query models directly", fromLayer: "controllers", toLayer: "models", allowed: false, severity: "medium", enforcement: "warn" },
+        { id: "controllers-use-services", name: "Controllers delegate to services", fromLayer: "controllers", toLayer: "services", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "services-use-repos", name: "Services use repositories for data access", fromLayer: "services", toLayer: "repositories", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "shared-no-controllers", name: "Shared must not import controllers", fromLayer: "shared", toLayer: "controllers", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
+    case "go-api":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "handlers-no-repos", name: "Handlers must not import repositories", fromLayer: "handlers", toLayer: "repositories", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "handlers-use-services", name: "Handlers call services only", fromLayer: "handlers", toLayer: "services", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "services-use-repos", name: "Services use repositories", fromLayer: "services", toLayer: "repositories", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "shared-no-services", name: "Shared must not import services", fromLayer: "shared", toLayer: "services", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
+    case "react":
+    case "react-native":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "components-no-pages", name: "Components must not import pages", fromLayer: "components", toLayer: "pages", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "components-no-store", name: "Presentational components must not read store", fromLayer: "components", toLayer: "store", allowed: false, severity: "medium", enforcement: "warn" },
+        { id: "services-no-components", name: "Services must not import components", fromLayer: "services", toLayer: "components", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "hooks-use-services", name: "Hooks use services for API calls", fromLayer: "hooks", toLayer: "services", allowed: true, severity: "low", enforcement: "suggest" }
+      ] };
+    case "vue":
+    case "nuxt":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "components-no-pages", name: "Components must not import pages/views", fromLayer: "components", toLayer: "pages", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "services-no-components", name: "Services must not import components", fromLayer: "services", toLayer: "components", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "composables-use-services", name: "Composables use services for API calls", fromLayer: "composables", toLayer: "services", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "store-no-components", name: "Store must not import components", fromLayer: "store", toLayer: "components", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
+    case "svelte":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "components-no-routes", name: "Components must not import route modules", fromLayer: "components", toLayer: "routes", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "stores-no-components", name: "Stores must not import components", fromLayer: "stores", toLayer: "components", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "utils-no-stores", name: "Utils must not import stores", fromLayer: "utils", toLayer: "stores", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
+    case "angular":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "components-no-services-in-template", name: "Components use DI \u2014 do not import services directly", fromLayer: "components", toLayer: "services", allowed: false, severity: "medium", enforcement: "warn" },
+        { id: "guards-use-services", name: "Guards use auth services", fromLayer: "guards", toLayer: "services", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "shared-no-modules", name: "Shared must not import feature modules", fromLayer: "shared", toLayer: "modules", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
+    case "hexagonal":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "domain-no-adapters", name: "Domain must not import adapters", fromLayer: "domain", toLayer: "adapters", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "domain-no-infra", name: "Domain must not import infrastructure", fromLayer: "domain", toLayer: "infrastructure", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "adapters-implement-ports", name: "Adapters implement port interfaces", fromLayer: "adapters", toLayer: "ports", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "ports-no-adapters", name: "Ports must not import adapters", fromLayer: "ports", toLayer: "adapters", allowed: false, severity: "critical", enforcement: "block" }
+      ] };
+    case "modular-monolith":
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "modules-no-direct-import", name: "Modules must not import each other directly", fromLayer: "modules", toLayer: "modules", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "shared-no-modules", name: "Shared kernel must not import feature modules", fromLayer: "shared", toLayer: "modules", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "modules-use-shared", name: "Modules may use shared kernel", fromLayer: "modules", toLayer: "shared", allowed: true, severity: "low", enforcement: "suggest" }
+      ] };
+    default:
+      return { rules: [
+        { id: "no-circular", name: "No circular dependencies", fromLayer: "*", toLayer: "*", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "domain-no-infra", name: "Domain must not import infrastructure", fromLayer: "domain", toLayer: "infrastructure", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "domain-no-api", name: "Domain must not import API layer", fromLayer: "domain", toLayer: "api", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "api-no-infra-direct", name: "API should not import infrastructure directly", fromLayer: "api", toLayer: "infrastructure", allowed: false, severity: "medium", enforcement: "warn" },
+        { id: "application-no-api", name: "Application must not import API layer", fromLayer: "application", toLayer: "api", allowed: false, severity: "critical", enforcement: "block" },
+        { id: "application-uses-domain", name: "Application depends on domain", fromLayer: "application", toLayer: "domain", allowed: true, severity: "low", enforcement: "suggest" },
+        { id: "shared-no-domain", name: "Shared must not import domain", fromLayer: "shared", toLayer: "domain", allowed: false, severity: "medium", enforcement: "warn" }
+      ] };
   }
-  return {
-    layers: [
-      { name: "domain", paths: ["src/domain/**", "src/core/domain/**", "src/modules/*/domain/**"], description: "Business logic, entities, use cases" },
-      { name: "application", paths: ["src/application/**", "src/core/application/**", "src/modules/*/application/**"], description: "Use cases and orchestration" },
-      { name: "infrastructure", paths: ["src/infrastructure/**", "src/modules/*/infrastructure/**"], description: "Database, external APIs, low-level I/O" },
-      { name: "api", paths: ["src/api/**", "src/interfaces/**", "src/controllers/**"], description: "HTTP handlers, request/response" },
-      { name: "shared", paths: ["src/shared/**", "src/utils/**", "src/helpers/**"], description: "Utilities, helpers, constants" }
-    ]
-  };
 }
 function getArchmindDir() {
   return ARCHMIND_DIR;