@c0x12c/spartan-ai-toolkit 1.6.5 → 1.7.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "spartan-ai-toolkit",
       "description": "5 workflows, 56 commands, 12 rules, 22 skills, 7 agents — organized in 11 packs with dependencies",
       "source": "./toolkit",
-      "version": "1.6.5"
+      "version": "1.7.0"
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "spartan-ai-toolkit",
-  "version": "1.6.5",
+  "version": "1.7.0",
   "description": "Engineering discipline layer for Claude Code — 5 workflows, 56 commands, 12 rules, 22 skills, 7 agents organized in 11 packs",
   "author": {
     "name": "Khoa Tran",

package/VERSION

@@ -1 +1 @@
-1.6.5
+1.7.0

package/agents/phase-reviewer.md

@@ -81,26 +81,23 @@ Pick the right checks based on file types:
 
 ## How You Work
 
-1. **Load project rules first.** Before looking at any code, read the rule files that match the stack. These are the source of truth — they override your defaults.
+1. **Load rules from config.** Before looking at any code, find and read the project's rules.
 
-   **Find rules in this order** (use the first location that exists):
+   **Check for config first:**
+   ```bash
+   cat .spartan/config.yaml 2>/dev/null
+   ```
+
+   **If config exists:** read the `rules` section. Load all rule files listed for the current mode (backend/frontend/shared). If `extends` is set, load the base profile first, then apply overrides. If `conditional-rules` is set, match rules to changed files.
+
+   **If no config, scan for rules** (use the first location that has files):
    ```bash
    ls rules/ 2>/dev/null                    # project root
    ls .claude/rules/ 2>/dev/null             # project .claude dir
    ls ~/.claude/rules/ 2>/dev/null           # global install
    ```
 
-   **Backend rules (read if .kt files changed):**
-   - `rules/backend-micronaut/KOTLIN.md`
-   - `rules/backend-micronaut/CONTROLLERS.md`
-   - `rules/backend-micronaut/API_DESIGN.md`
-   - `rules/backend-micronaut/SERVICES_AND_BEANS.md`
-   - `rules/database/SCHEMA.md`
-   - `rules/database/ORM_AND_REPO.md`
-   - `rules/database/TRANSACTIONS.md`
-
-   **Frontend rules (read if .tsx/.ts files changed):**
-   - `rules/frontend-react/FRONTEND.md`
+   Read all `.md` files in the found rules directory. Group by subdirectory name to determine which mode they apply to.
 
    If a rule file doesn't exist, skip it. Don't guess what it says.
 

package/bin/cli.js

@@ -27,6 +27,7 @@ const SRC = {
   rules:      join(PKG_ROOT, 'rules'),
   skills:     join(PKG_ROOT, 'skills'),
   agents:     join(PKG_ROOT, 'agents'),
+  profiles:   join(PKG_ROOT, 'profiles'),
   claudeMd:   join(PKG_ROOT, 'claude-md'),
   version:    join(PKG_ROOT, 'VERSION'),
   claudePlugin: join(PKG_ROOT, '.claude-plugin'),
@@ -411,7 +412,7 @@ async function installFull() {
   console.log('');
 
   // 1) Assemble & install CLAUDE.md
-  console.log(`${blue('[1/5]')} ${bold('Assembling CLAUDE.md...')}`);
+  console.log(`${blue('[1/6]')} ${bold('Assembling CLAUDE.md...')}`);
 
   if (existsSync(targets.claudeMd)) {
     const backupPath = `${targets.claudeMd}.${Date.now()}.bak`;
@@ -427,7 +428,7 @@ async function installFull() {
   console.log(`  ${green('+')} CLAUDE.md assembled (${sectionCount} sections)\n`);
 
   // 2) Commands
-  console.log(`${blue('[2/5]')} ${bold('Installing commands...')}`);
+  console.log(`${blue('[2/6]')} ${bold('Installing commands...')}`);
   ensureDir(targets.commands);
   let cmdCount = 0;
 
@@ -454,7 +455,7 @@ async function installFull() {
   // 3) Rules (now with subdirectory structure)
   const rulesWithSource = gatherItemsWithSource(selectedPacks, 'rules');
   if (rulesWithSource.length > 0) {
-    console.log(`${blue('[3/5]')} ${bold('Installing rules...')}`);
+    console.log(`${blue('[3/6]')} ${bold('Installing rules...')}`);
     let ruleCount = 0;
 
     for (const { item: rule, srcRoot } of rulesWithSource) {
@@ -468,13 +469,13 @@ async function installFull() {
     }
     console.log(`  ${bold(ruleCount + ' rules')} installed\n`);
   } else {
-    console.log(`${blue('[3/5]')} ${bold('Rules')} — ${dim('no rule packs selected, skipping')}\n`);
+    console.log(`${blue('[3/6]')} ${bold('Rules')} — ${dim('no rule packs selected, skipping')}\n`);
   }
 
   // 4) Skills
   const skillsWithSource = gatherItemsWithSource(selectedPacks, 'skills');
   if (skillsWithSource.length > 0) {
-    console.log(`${blue('[4/5]')} ${bold('Installing skills...')}`);
+    console.log(`${blue('[4/6]')} ${bold('Installing skills...')}`);
     ensureDir(targets.skills);
     let skillCount = 0;
 
@@ -488,13 +489,13 @@ async function installFull() {
     }
     console.log(`  ${bold(skillCount + ' skills')} installed\n`);
   } else {
-    console.log(`${blue('[4/5]')} ${bold('Skills')} — ${dim('no skill packs selected, skipping')}\n`);
+    console.log(`${blue('[4/6]')} ${bold('Skills')} — ${dim('no skill packs selected, skipping')}\n`);
   }
 
   // 5) Agents
   const agentsWithSource = gatherItemsWithSource(selectedPacks, 'agents');
   if (agentsWithSource.length > 0) {
-    console.log(`${blue('[5/5]')} ${bold('Installing agents...')}`);
+    console.log(`${blue('[5/6]')} ${bold('Installing agents...')}`);
     ensureDir(targets.agents);
     let agentCount = 0;
 
@@ -508,7 +509,27 @@ async function installFull() {
     }
     console.log(`  ${bold(agentCount + ' agents')} installed\n`);
   } else {
-    console.log(`${blue('[5/5]')} ${bold('Agents')} — ${dim('no agent packs selected, skipping')}\n`);
+    console.log(`${blue('[5/6]')} ${bold('Agents')} — ${dim('no agent packs selected, skipping')}\n`);
+  }
+
+  // 6) Generate .spartan/config.yaml from best matching profile
+  const configDir = mode === 'global'
+    ? join(homedir(), '.spartan')
+    : join(process.cwd(), '.spartan');
+  const configPath = join(configDir, 'config.yaml');
+
+  if (!existsSync(configPath)) {
+    const profile = pickProfile(selectedPacks);
+    const profileSrc = join(SRC.profiles, `${profile}.yaml`);
+
+    if (existsSync(profileSrc)) {
+      ensureDir(configDir);
+      copyFile(profileSrc, configPath);
+      console.log(`${blue('[6/6]')} ${bold('Generated .spartan/config.yaml')} from ${cyan(profile)} profile`);
+      console.log(`  ${dim('Edit this file to customize rules, review stages, and build commands')}\n`);
+    }
+  } else {
+    console.log(`${blue('[6/6]')} ${bold('.spartan/config.yaml')} — ${dim('already exists, kept as-is')}\n`);
   }
 
   // Save pack selection + version
@@ -520,6 +541,24 @@ async function installFull() {
   return selectedPacks;
 }
 
+// ── Profile picker ─────────────────────────────────────────────
+// Maps selected packs to the best matching stack profile.
+function pickProfile(selectedPacks) {
+  const packSet = new Set(selectedPacks);
+
+  // Check for specific stack packs first
+  if (packSet.has('backend-micronaut') && packSet.has('frontend-react')) {
+    return 'kotlin-micronaut'; // full-stack defaults to backend profile
+  }
+  if (packSet.has('backend-micronaut')) return 'kotlin-micronaut';
+  if (packSet.has('frontend-react'))    return 'react-nextjs';
+  if (packSet.has('backend-nodejs'))    return 'typescript-node';
+  if (packSet.has('backend-python'))    return 'python-fastapi';
+
+  // No stack-specific pack → use custom
+  return 'custom';
+}
+
 // ── Install for cursor / windsurf / copilot ─────────────────────
 async function installRulesOnly() {
   const targets = getTargets();

package/commands/spartan/build.md

@@ -403,29 +403,46 @@ npm test && npm run build
 
 **This is NOT a self-review.** Spawn a separate review agent to get a fresh perspective. The reviewer finds issues, you fix them, repeat until clean.
 
-### Step 1: Gather review context
+### Step 1: Load rules from config
 
-Before spawning the reviewer, collect everything it needs:
+The review uses **configurable rules**. Load them in this order:
 
 ```bash
-# 1. Get changed files by type
-git diff main...HEAD --name-only | grep '\.kt$'   # backend files
-git diff main...HEAD --name-only | grep '\.tsx\?$' # frontend files
-git diff main...HEAD --name-only | grep '\.sql$'   # migration files
+# 1. Check for project config (source of truth)
+cat .spartan/config.yaml 2>/dev/null
 
-# 2. Find spec and plan for this feature
-ls .planning/specs/*.md .planning/plans/*.md .planning/designs/*.md 2>/dev/null
+# 2. If no config, scan for installed rules
+ls rules/ .claude/rules/ ~/.claude/rules/ 2>/dev/null
+```
+
+**If `.spartan/config.yaml` exists:**
+- Read the `rules` section → get rule file paths for the current mode
+- Read the `review-stages` section → get which stages to run
+- Read `file-types` section → classify changed files by mode
+- If `extends` is set, load the base profile first, then apply overrides (`rules-add`, `rules-remove`, `rules-override`)
+- If `conditional-rules` is set, match rules to changed files by glob pattern
+
+**If no config exists (fallback):**
+- Scan `rules/` directory for all `.md` files
+- Group by subdirectory: `rules/backend-micronaut/` → backend, `rules/frontend-react/` → frontend, `rules/database/` → backend, `rules/core/` → shared
+- If no `rules/` dir, check `.claude/rules/` then `~/.claude/rules/`
+- Use all 7 default review stages
+
+### Step 2: Gather review context
+
+```bash
+# Get changed files by type (use file-types from config if available)
+git diff main...HEAD --name-only
 
-# 3. Find installed rules (pick based on mode)
-ls rules/backend-micronaut/ rules/database/ rules/frontend-react/ 2>/dev/null
-# Also check ~/.claude/rules/ if project rules/ not found
+# Find spec and plan for this feature
+ls .planning/specs/*.md .planning/plans/*.md .planning/designs/*.md 2>/dev/null
 ```
 
-### Step 2: Spawn the review agent
+Classify each changed file into backend/frontend/migration using the `file-types` from config (or defaults: `.kt/.java/.go/.py` = backend, `.tsx/.ts/.vue` = frontend, `.sql` = migration).
 
-Use the `Agent` tool to spawn a reviewer. **The prompt changes based on mode.**
+### Step 3: Spawn the review agent
 
-Build the prompt from these blocks — include only what matches the mode:
+Use the `Agent` tool to spawn a reviewer. **The prompt is built from the config.**
 
 ```
 Agent:
@@ -435,9 +452,9 @@ Agent:
     You are reviewing code changes for the feature: {feature name}.
 
     ## What changed
-    - Backend files: {list .kt files from git diff, or "none"}
-    - Frontend files: {list .tsx/.ts files from git diff, or "none"}
-    - Migration files: {list .sql files from git diff, or "none"}
+    - Backend files: {list from git diff, classified by file-types config}
+    - Frontend files: {list from git diff}
+    - Migration files: {list from git diff}
     - Design doc: {path if exists, or "none"}
 
     ## Spec and plan
@@ -448,62 +465,65 @@ Agent:
     ## Rules to check against
     Read these rule files BEFORE reviewing code. They are the source of truth.
 
-    {IF backend or full-stack mode, include:}
-    **Backend rules (read all of these):**
-    - `rules/backend-micronaut/KOTLIN.md` — null safety, Either error handling, coroutines, no `!!`
-    - `rules/backend-micronaut/CONTROLLERS.md` — thin controllers, @ExecuteOn, @Secured, delegate to Manager
-    - `rules/backend-micronaut/API_DESIGN.md` — query params only, RPC-style URLs, no path params
-    - `rules/backend-micronaut/SERVICES_AND_BEANS.md` — Manager returns Either, service layer patterns
-    - `rules/database/SCHEMA.md` — TEXT not VARCHAR, no FK, soft deletes, UUID PKs, standard columns
-    - `rules/database/ORM_AND_REPO.md` — Exposed ORM, repository pattern
-    - `rules/database/TRANSACTIONS.md` — transaction(db.primary) {} for multi-table ops
-
-    {IF frontend or full-stack mode, include:}
-    **Frontend rules (read all of these):**
-    - `rules/frontend-react/FRONTEND.md` — build check before commit, API case conversion, null safety, optimistic updates
-
-    {IF design doc exists, include:}
+    {List ALL rule paths from config, grouped by mode. Example:}
+
+    **Backend rules (from .spartan/config.yaml):**
+    {for each rule in config.rules.backend + config.rules.shared:}
+    - `{rule path}`
+    {end for}
+
+    **Frontend rules (from .spartan/config.yaml):**
+    {for each rule in config.rules.frontend + config.rules.shared:}
+    - `{rule path}`
+    {end for}
+
+    **Conditional rules (if any):**
+    {for each conditional rule where changed files match applies-to:}
+    - `{rule path}` — applies to files matching `{glob}`
+    {end for}
+
+    {IF design doc exists:}
     **Design compliance:**
     - Read the design doc at {path}. Check that UI matches the approved design.
-    - Flag any component that looks different from the design spec.
 
-    ## Review stages (check all that apply)
+    ## Review stages
+    {List ONLY the stages that are enabled in config.review-stages.
+     For each stage, include its name and description from config.
+     If no config, use all 7 defaults below.}
 
     **Stage 1 — Correctness & Requirements**
     - Does the code match the spec? Any missing requirements?
     - Are all edge cases handled?
-    - Is error handling using Either (not thrown exceptions)?
+    - Error handling follows the project's approach (check the rules)?
 
     **Stage 2 — Stack Conventions**
-    {backend}: Controllers thin? Manager has business logic? Either<ClientException, T>? No `!!`? @ExecuteOn on blocking calls? @Secured on controllers?
-    {frontend}: Strict TypeScript? No `any`? Hooks rules followed? Server vs client components correct?
+    - Code follows the patterns described in the loaded rule files?
+    - Stack idioms are correct for this language/framework?
 
     **Stage 3 — Test Coverage**
-    - New endpoints have @MicronautTest integration tests?
+    - Tests exist for new code?
     - Tests are independent (no order dependency)?
-    - Edge cases tested? Happy path + error paths?
-    - Frontend: components tested with Testing Library?
+    - Edge cases covered? Happy path + error paths?
 
     **Stage 4 — Architecture & Clean Code**
-    - Layered: Controller → Manager → Service/Repository?
-    - No business logic in controllers or repositories?
+    - Architecture matches what the config says (layered, hexagonal, etc.)?
+    - Proper separation between layers?
     - Functions small and focused? No deep nesting?
     - No duplication, no dead code?
 
     **Stage 5 — Database & API**
-    - Migration uses TEXT not VARCHAR? No FK constraints?
-    - Soft delete with deleted_at? Standard columns (id, created_at, updated_at, deleted_at)?
-    - UUID primary keys? Input validation on public endpoints?
-    - API URLs follow RPC style?
+    - Schema follows the rules? (check loaded database rules)
+    - API design follows the rules? (check loaded API rules)
+    - Input validation on public endpoints?
 
     **Stage 6 — Security**
     - Auth checks on all endpoints?
     - Input validated and sanitized?
-    - No sensitive data logged or exposed in responses?
-    - No SQL injection, XSS, or command injection risks?
+    - No sensitive data logged or exposed?
+    - No injection risks?
 
     **Stage 7 — Documentation Gaps**
-    - New pattern used that should be documented? → flag for rules update
+    - New pattern that should be documented? → flag for rules update
     - New convention established? → flag for .memory/patterns/
     - Recurring issue that should become a rule? → flag it
 
@@ -512,13 +532,13 @@ Agent:
     For each issue:
     - File and line number
     - What's wrong
-    - Which rule it breaks (with rule file reference)
+    - Which rule it breaks (with rule file path)
     - Severity: HIGH (must fix) / MEDIUM (should fix) / LOW (nice to have)
     - Suggested fix
 
     End with:
     - **PASS** or **NEEDS CHANGES** (list all HIGH/MEDIUM issues)
-    - **Documentation updates needed** (list any rule/pattern updates from Stage 7, or "none")
+    - **Documentation updates needed** (list any from Stage 7, or "none")
     - **What's clean** (always include — praise good code)
 ```
 

package/commands/spartan/fe-review.md

@@ -1,16 +1,36 @@
 ---
 name: spartan:fe-review
-description: Thorough PR review for React/Next.js code — App Router conventions, performance, accessibility, TypeScript strictness, and test coverage.
+description: Thorough PR review for frontend code — loads rules from config, defaults to React/Next.js conventions
 argument-hint: "[optional: PR title or focus area]"
 ---
 
 # Frontend PR Review: {{ args[0] | default: "current branch" }}
 
-Performing a comprehensive review of React/Next.js changes.
-Run `git diff main...HEAD` and analyze all modified FE files.
+Performing a thorough review of frontend changes.
+
+## Step 0: Load rules
+
+```bash
+# Check for project config
+cat .spartan/config.yaml 2>/dev/null
+
+# Get changed frontend files
+git diff main...HEAD --name-only | grep -E '\.(tsx?|jsx?|vue|svelte|css)$'
+```
+
+**If `.spartan/config.yaml` exists:**
+- Read `rules.frontend` + `rules.shared` — check against these rules
+- Read `review-stages` — only run enabled stages
+- If `conditional-rules` is set, match rules to changed files
+
+**If no config:** Use the default React/Next.js checklist below + scan for `rules/frontend-react/` or `~/.claude/rules/frontend-react/`.
+
+Read all matched rule files before reviewing code.
 
 ---
 
+Run `git diff main...HEAD` and analyze all modified frontend files.
+
 ## Stage 1: App Router Conventions
 
 - [ ] New pages use **Server Components by default**