@c0x12c/ai-toolkit 1.15.0

package/lib/assembler.js

@@ -0,0 +1,197 @@
+// Spartan AI Toolkit — Assembler
+// Builds CLAUDE.md and AGENTS.md from section files based on selected packs.
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ALWAYS_INCLUDE_TOP = ['00-header.md', '01-core.md'];
+const ALWAYS_INCLUDE_BOTTOM = ['90-footer.md'];
+
+/**
+ * Assemble CLAUDE.md from section files.
+ * @param {string} claudeMdDir - Path to the claude-md/ directory
+ * @param {string[]} selectedPacks - Pack names the user picked
+ * @param {object} packDefs - The PACKS object from packs.js
+ * @returns {string} The full CLAUDE.md content
+ */
+export function assembleCLAUDEmd(claudeMdDir, selectedPacks, packDefs) {
+  let parts = [];
+
+  // Always include header + core
+  for (const file of ALWAYS_INCLUDE_TOP) {
+    const fp = join(claudeMdDir, file);
+    if (existsSync(fp)) {
+      parts.push(readFileSync(fp, 'utf-8'));
+    }
+  }
+
+  // Pack-specific sections (in pack order, not random)
+  const seen = new Set();
+  for (const pack of selectedPacks) {
+    const def = packDefs[pack];
+    if (!def) continue;
+    for (const section of def.claudeSections) {
+      if (seen.has(section)) continue;
+      seen.add(section);
+      const fp = join(claudeMdDir, section);
+      if (existsSync(fp)) {
+        parts.push(readFileSync(fp, 'utf-8'));
+      }
+    }
+  }
+
+  // Always include footer
+  for (const file of ALWAYS_INCLUDE_BOTTOM) {
+    const fp = join(claudeMdDir, file);
+    if (existsSync(fp)) {
+      parts.push(readFileSync(fp, 'utf-8'));
+    }
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Assemble AGENTS.md from section files + agent definitions.
+ * Follows the AGENTS.md spec: Project Context, pack content, Agents, Boundaries.
+ * @param {string} claudeMdDir - Path to the claude-md/ directory
+ * @param {string} agentsDir - Path to the agents/ directory
+ * @param {string[]} selectedPacks - Pack names the user picked
+ * @param {object} packDefs - The PACKS object from packs.js
+ * @returns {string} The full AGENTS.md content
+ */
+export function assembleAGENTSmd(claudeMdDir, agentsDir, selectedPacks, packDefs) {
+  const parts = [];
+
+  // Header
+  parts.push('# AGENTS.md');
+  parts.push('');
+  parts.push('> Generated by [Spartan AI Toolkit](https://github.com/c0x12c/ai-toolkit)');
+  parts.push('');
+
+  // Project Context — pull from header if it exists
+  parts.push('## Project Context');
+  parts.push('');
+  const headerFile = join(claudeMdDir, '00-header.md');
+  if (existsSync(headerFile)) {
+    const header = readFileSync(headerFile, 'utf-8');
+    // Strip the top-level heading, keep the useful content
+    const lines = header.split('\n');
+    const contentLines = lines.filter(l => !l.startsWith('# '));
+    const trimmed = contentLines.join('\n').trim();
+    if (trimmed) {
+      parts.push(trimmed);
+      parts.push('');
+    }
+  }
+
+  // Core principles — compact version
+  const coreFile = join(claudeMdDir, '01-core.md');
+  if (existsSync(coreFile)) {
+    const core = readFileSync(coreFile, 'utf-8');
+    parts.push(extractSection(core));
+    parts.push('');
+  }
+
+  // Pack-specific sections
+  const seen = new Set();
+  for (const pack of selectedPacks) {
+    const def = packDefs[pack];
+    if (!def) continue;
+    for (const section of def.claudeSections) {
+      if (seen.has(section)) continue;
+      seen.add(section);
+      const fp = join(claudeMdDir, section);
+      if (existsSync(fp)) {
+        parts.push(extractSection(readFileSync(fp, 'utf-8')));
+        parts.push('');
+      }
+    }
+  }
+
+  // Agents — list available agents from selected packs
+  const agentFiles = gatherAgents(selectedPacks, packDefs);
+  if (agentFiles.length > 0 && agentsDir) {
+    parts.push('## Available Agents');
+    parts.push('');
+    for (const agentFile of agentFiles) {
+      const fp = join(agentsDir, agentFile);
+      if (!existsSync(fp)) continue;
+      const content = readFileSync(fp, 'utf-8');
+      const name = extractFrontmatterField(content, 'name') || agentFile.replace('.md', '');
+      const desc = extractFrontmatterField(content, 'description') || '';
+      // Handle multiline descriptions — get first meaningful sentence
+      const cleanDesc = desc.replace(/\\n/g, ' ').split('.')[0].trim();
+      parts.push(`- **${name}**: ${cleanDesc}`);
+    }
+    parts.push('');
+  }
+
+  // Boundaries — from footer "What NOT to Do" section
+  const footerFile = join(claudeMdDir, '90-footer.md');
+  if (existsSync(footerFile)) {
+    const footer = readFileSync(footerFile, 'utf-8');
+    const neverItems = extractNotToDoItems(footer);
+    if (neverItems.length > 0) {
+      parts.push('## Boundaries');
+      parts.push('');
+      parts.push('**NEVER:**');
+      for (const item of neverItems) {
+        parts.push(`- ${item}`);
+      }
+      parts.push('');
+    }
+  }
+
+  return parts.join('\n').trimEnd() + '\n';
+}
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+/** Strip leading separator (---) and return the content. */
+function extractSection(content) {
+  return content.replace(/^\s*---\s*\n?/, '').trim();
+}
+
+/** Get deduplicated agent files from selected packs. */
+function gatherAgents(selectedPacks, packDefs) {
+  const seen = new Set();
+  const result = [];
+  for (const pack of selectedPacks) {
+    const def = packDefs[pack];
+    if (!def) continue;
+    for (const agent of (def.agents || [])) {
+      if (!seen.has(agent)) {
+        seen.add(agent);
+        result.push(agent);
+      }
+    }
+  }
+  return result;
+}
+
+/** Extract a YAML frontmatter field value (simple single-line). */
+function extractFrontmatterField(content, field) {
+  const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, 'm'));
+  return match ? match[1].trim().replace(/^["']|["']$/g, '') : null;
+}
+
+/** Extract items from the "What NOT to Do" section only. */
+function extractNotToDoItems(content) {
+  const lines = content.split('\n');
+  let inSection = false;
+  const items = [];
+  for (const line of lines) {
+    if (line.match(/what not to do/i)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && line.match(/^#{1,3}\s/)) {
+      break; // hit next section
+    }
+    if (inSection && line.match(/^-\s+/)) {
+      items.push(line.replace(/^-\s+/, '').trim());
+    }
+  }
+  return items;
+}

package/lib/assembler.test.js

@@ -0,0 +1,159 @@
+// Spartan AI Toolkit — Assembler Tests
+// Run: node --test toolkit/lib/assembler.test.js
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { assembleCLAUDEmd, assembleAGENTSmd } from './assembler.js';
+
+// ── Test fixtures ────────────────────────────────────────────────
+const TMP = join(import.meta.dirname, '..', '.test-tmp-assembler');
+
+function setupFixtures() {
+  rmSync(TMP, { recursive: true, force: true });
+
+  // claude-md sections
+  const claudeMd = join(TMP, 'claude-md');
+  mkdirSync(claudeMd, { recursive: true });
+  writeFileSync(join(claudeMd, '00-header.md'), '# Spartan AI Toolkit\n\nIntro text here.');
+  writeFileSync(join(claudeMd, '01-core.md'), '\n---\n\n## Core Principles\n\n- TDD always\n- Spec before code');
+  writeFileSync(join(claudeMd, '11-backend.md'), '\n---\n\n## Backend\n\nKotlin + Micronaut stack.\n\n| Command | Purpose |\n|---|---|\n| `/spartan:build` | Build feature |');
+  writeFileSync(join(claudeMd, '20-frontend.md'), '\n---\n\n## Frontend\n\nReact + Next.js stack.');
+  writeFileSync(join(claudeMd, '90-footer.md'), '\n---\n\n## What NOT to Do\n\n- Don\'t skip tests');
+
+  // agents
+  const agents = join(TMP, 'agents');
+  mkdirSync(agents, { recursive: true });
+  writeFileSync(join(agents, 'backend-expert.md'), '---\nname: backend-expert\ndescription: Backend expert\nmodel: sonnet\n---\n\nYou are a backend expert.');
+  writeFileSync(join(agents, 'cto.md'), '---\nname: cto\ndescription: CTO advisor\nmodel: sonnet\n---\n\nYou are a CTO.');
+
+  return { claudeMd, agents };
+}
+
+function cleanup() {
+  rmSync(TMP, { recursive: true, force: true });
+}
+
+// Mock pack definitions
+const packDefs = {
+  core: { claudeSections: [], rules: [], skills: [], agents: [], commands: [] },
+  backend: {
+    claudeSections: ['11-backend.md'],
+    rules: ['backend/KOTLIN.md'],
+    skills: ['api-endpoint-creator'],
+    agents: ['backend-expert.md'],
+    commands: ['build'],
+  },
+  frontend: {
+    claudeSections: ['20-frontend.md'],
+    rules: ['frontend/FRONTEND.md'],
+    skills: ['ui-ux-pro-max'],
+    agents: [],
+    commands: ['next-app'],
+  },
+};
+
+// ── Tests ────────────────────────────────────────────────────────
+
+describe('assembleCLAUDEmd', () => {
+  it('includes header, core, pack sections, and footer', () => {
+    const { claudeMd } = setupFixtures();
+    try {
+      const result = assembleCLAUDEmd(claudeMd, ['backend'], packDefs);
+      assert.ok(result.includes('# Spartan AI Toolkit'), 'should have header');
+      assert.ok(result.includes('Core Principles'), 'should have core');
+      assert.ok(result.includes('Backend'), 'should have backend section');
+      assert.ok(result.includes('What NOT to Do'), 'should have footer');
+      assert.ok(!result.includes('Frontend'), 'should NOT have frontend');
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe('assembleAGENTSmd', () => {
+  it('returns a string with AGENTS.md header', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend'], packDefs);
+      assert.ok(typeof result === 'string');
+      assert.ok(result.includes('# AGENTS.md'), 'should have AGENTS.md header');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('includes project context section', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend'], packDefs);
+      assert.ok(result.includes('## Project Context'), 'should have project context');
+      assert.ok(result.includes('Spartan AI Toolkit'), 'should mention toolkit name');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('includes pack-specific content', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend'], packDefs);
+      assert.ok(result.includes('Backend') || result.includes('backend'), 'should have backend content');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('does NOT include packs the user did not pick', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend'], packDefs);
+      assert.ok(!result.includes('## Frontend'), 'should NOT have frontend section');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('includes agents section when agents exist', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend'], packDefs);
+      assert.ok(result.includes('backend-expert') || result.includes('Agents'), 'should have agents');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('includes boundaries section', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend'], packDefs);
+      assert.ok(result.includes('## Boundaries') || result.includes('NEVER'), 'should have boundaries');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('handles multiple packs', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['backend', 'frontend'], packDefs);
+      assert.ok(result.includes('Backend') || result.includes('backend'), 'should have backend');
+      assert.ok(result.includes('Frontend') || result.includes('frontend'), 'should have frontend');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('handles empty packs gracefully', () => {
+    const { claudeMd, agents } = setupFixtures();
+    try {
+      const result = assembleAGENTSmd(claudeMd, agents, ['core'], packDefs);
+      assert.ok(typeof result === 'string');
+      assert.ok(result.includes('# AGENTS.md'));
+    } finally {
+      cleanup();
+    }
+  });
+});

package/lib/detector.js

@@ -0,0 +1,166 @@
+// Spartan AI Toolkit — Stack Detector
+// Scans a project directory to detect tech stacks and map them to packs.
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Packs that are "coming soon" — detect but don't auto-select
+const COMING_SOON = new Set(['backend-nodejs', 'backend-python']);
+
+// Skip these directories when scanning 1 level deep
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '.gradle', 'build', 'dist', 'target',
+  '.next', '.nuxt', '__pycache__', '.venv', 'venv', '.idea',
+]);
+
+/**
+ * Detect tech stacks in a project directory.
+ * Scans root + 1 level deep for stack markers.
+ * @param {string} cwd - Directory to scan
+ * @returns {{ detected: Array<{pack: string, reason: string}>, comingSoon: Array<{pack: string, reason: string}> }}
+ */
+export function detectStacks(cwd) {
+  const detected = [];
+  const comingSoon = [];
+  const seen = new Set();
+
+  // Scan root
+  scanDir(cwd, '', detected, comingSoon, seen);
+
+  // Scan 1 level deep
+  try {
+    const entries = readdirSync(cwd);
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry) || entry.startsWith('.')) continue;
+      const full = join(cwd, entry);
+      try {
+        if (statSync(full).isDirectory()) {
+          scanDir(full, entry, detected, comingSoon, seen);
+        }
+      } catch { /* ignore permission errors */ }
+    }
+  } catch { /* ignore if cwd can't be read */ }
+
+  return { detected, comingSoon };
+}
+
+function scanDir(dir, label, detected, comingSoon, seen) {
+  // ── Kotlin + Micronaut ───────────────────────────────────────
+  if (!seen.has('backend-micronaut')) {
+    const gradleFile = join(dir, 'build.gradle.kts');
+    const pomFile = join(dir, 'pom.xml');
+    const mnCliFile = join(dir, 'micronaut-cli.yml');
+
+    if (existsSync(gradleFile)) {
+      const content = readSafe(gradleFile);
+      if (content.includes('io.micronaut')) {
+        addResult('backend-micronaut', `build.gradle.kts${label ? ` in ${label}/` : ''} → Micronaut`, detected, comingSoon, seen);
+      }
+    }
+    if (!seen.has('backend-micronaut') && existsSync(pomFile)) {
+      const content = readSafe(pomFile);
+      if (content.includes('io.micronaut') || content.includes('micronaut-')) {
+        addResult('backend-micronaut', `pom.xml${label ? ` in ${label}/` : ''} → Micronaut`, detected, comingSoon, seen);
+      }
+    }
+    if (!seen.has('backend-micronaut') && existsSync(mnCliFile)) {
+      addResult('backend-micronaut', `micronaut-cli.yml${label ? ` in ${label}/` : ''}`, detected, comingSoon, seen);
+    }
+  }
+
+  // ── React / Next.js ──────────────────────────────────────────
+  if (!seen.has('frontend-react')) {
+    // Check next.config.* files first (high confidence)
+    for (const cfg of ['next.config.js', 'next.config.ts', 'next.config.mjs']) {
+      if (existsSync(join(dir, cfg))) {
+        addResult('frontend-react', `${cfg}${label ? ` in ${label}/` : ''} → Next.js`, detected, comingSoon, seen);
+        break;
+      }
+    }
+
+    // Check package.json for next or react
+    if (!seen.has('frontend-react')) {
+      const pkg = readPackageJson(dir);
+      if (pkg) {
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (allDeps.next) {
+          addResult('frontend-react', `package.json${label ? ` in ${label}/` : ''} → Next.js`, detected, comingSoon, seen);
+        } else if (allDeps.react) {
+          addResult('frontend-react', `package.json${label ? ` in ${label}/` : ''} → React`, detected, comingSoon, seen);
+        }
+      }
+    }
+  }
+
+  // ── Node.js Backend ──────────────────────────────────────────
+  // Only check if frontend-react was NOT found in this same package.json
+  if (!seen.has('backend-nodejs') && !seen.has('frontend-react-from-pkg-' + dir)) {
+    const pkg = readPackageJson(dir);
+    if (pkg) {
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      // Skip if this package has next or react (it's frontend, not backend)
+      if (!allDeps.next && !allDeps.react) {
+        const nodeBackendFrameworks = ['express', 'fastify', '@nestjs/core', 'koa', '@hapi/hapi', 'hapi'];
+        const found = nodeBackendFrameworks.find(f => allDeps[f]);
+        if (found) {
+          addResult('backend-nodejs', `package.json${label ? ` in ${label}/` : ''} → ${found}`, detected, comingSoon, seen);
+        }
+      }
+    }
+  }
+
+  // ── Python Backend ───────────────────────────────────────────
+  if (!seen.has('backend-python')) {
+    const pythonFrameworks = ['fastapi', 'django', 'flask', 'starlette'];
+
+    // manage.py → Django
+    if (existsSync(join(dir, 'manage.py'))) {
+      addResult('backend-python', `manage.py${label ? ` in ${label}/` : ''} → Django`, detected, comingSoon, seen);
+    }
+
+    // pyproject.toml
+    if (!seen.has('backend-python') && existsSync(join(dir, 'pyproject.toml'))) {
+      const content = readSafe(join(dir, 'pyproject.toml')).toLowerCase();
+      const found = pythonFrameworks.find(f => content.includes(f));
+      if (found) {
+        addResult('backend-python', `pyproject.toml${label ? ` in ${label}/` : ''} → ${found}`, detected, comingSoon, seen);
+      }
+    }
+
+    // requirements.txt
+    if (!seen.has('backend-python') && existsSync(join(dir, 'requirements.txt'))) {
+      const content = readSafe(join(dir, 'requirements.txt')).toLowerCase();
+      const found = pythonFrameworks.find(f => content.includes(f));
+      if (found) {
+        addResult('backend-python', `requirements.txt${label ? ` in ${label}/` : ''} → ${found}`, detected, comingSoon, seen);
+      }
+    }
+  }
+}
+
+function addResult(pack, reason, detected, comingSoon, seen) {
+  seen.add(pack);
+  if (COMING_SOON.has(pack)) {
+    comingSoon.push({ pack, reason });
+  } else {
+    detected.push({ pack, reason });
+  }
+}
+
+function readSafe(filePath) {
+  try {
+    return readFileSync(filePath, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+function readPackageJson(dir) {
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}