@c0x12c/ai-toolkit 1.15.0

package/lib/detector.test.js

@@ -0,0 +1,221 @@
+// Spartan AI Toolkit — Stack Detector Tests
+// Run: node --test toolkit/lib/detector.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 { detectStacks } from './detector.js';
+
+// ── Test fixtures ────────────────────────────────────────────────
+const TMP = join(import.meta.dirname, '..', '.test-tmp-detector');
+
+function setup() {
+  rmSync(TMP, { recursive: true, force: true });
+  mkdirSync(TMP, { recursive: true });
+}
+
+function cleanup() {
+  rmSync(TMP, { recursive: true, force: true });
+}
+
+// ── Tests ────────────────────────────────────────────────────────
+
+describe('detectStacks', () => {
+  it('detects Kotlin + Micronaut from build.gradle.kts', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'build.gradle.kts'), `
+plugins {
+    id("io.micronaut.application") version "4.0.0"
+}
+dependencies {
+    implementation("io.micronaut:micronaut-http-server-netty")
+}
+`);
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'backend-micronaut'), 'should detect backend-micronaut');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects React + Next.js from package.json', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'package.json'), JSON.stringify({
+        dependencies: { next: '14.0.0', react: '18.0.0' },
+      }));
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'frontend-react'), 'should detect frontend-react');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects React without Next.js', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'package.json'), JSON.stringify({
+        dependencies: { react: '18.0.0', 'react-dom': '18.0.0' },
+      }));
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'frontend-react'), 'should detect frontend-react');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects Next.js from next.config.js', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'next.config.js'), 'module.exports = {};');
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'frontend-react'), 'should detect frontend-react');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects Node.js backend (express) — marks as coming soon', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'package.json'), JSON.stringify({
+        dependencies: { express: '4.18.0' },
+      }));
+      const result = detectStacks(TMP);
+      assert.ok(!result.detected.some(d => d.pack === 'backend-nodejs'), 'should NOT be in detected');
+      assert.ok(result.comingSoon.some(d => d.pack === 'backend-nodejs'), 'should be in comingSoon');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects Python backend (FastAPI) — marks as coming soon', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'requirements.txt'), 'fastapi==0.100.0\nuvicorn==0.23.0\n');
+      const result = detectStacks(TMP);
+      assert.ok(!result.detected.some(d => d.pack === 'backend-python'), 'should NOT be in detected');
+      assert.ok(result.comingSoon.some(d => d.pack === 'backend-python'), 'should be in comingSoon');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects Django from manage.py', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'manage.py'), '#!/usr/bin/env python\nimport django\n');
+      const result = detectStacks(TMP);
+      assert.ok(result.comingSoon.some(d => d.pack === 'backend-python'), 'should detect python as coming soon');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects Micronaut from pom.xml', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'pom.xml'), `
+<project>
+  <dependencies>
+    <dependency>
+      <groupId>io.micronaut</groupId>
+      <artifactId>micronaut-http-server-netty</artifactId>
+    </dependency>
+  </dependencies>
+</project>
+`);
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'backend-micronaut'), 'should detect backend-micronaut');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('returns empty for empty directory', () => {
+    setup();
+    try {
+      const result = detectStacks(TMP);
+      assert.equal(result.detected.length, 0);
+      assert.equal(result.comingSoon.length, 0);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects both backend and frontend in same project', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'build.gradle.kts'), 'id("io.micronaut.application")');
+      writeFileSync(join(TMP, 'package.json'), JSON.stringify({
+        dependencies: { next: '14.0.0', react: '18.0.0' },
+      }));
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'backend-micronaut'), 'should detect backend');
+      assert.ok(result.detected.some(d => d.pack === 'frontend-react'), 'should detect frontend');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('prefers frontend-react over backend-nodejs when both next and express are present', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'package.json'), JSON.stringify({
+        dependencies: { next: '14.0.0', react: '18.0.0', express: '4.18.0' },
+      }));
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'frontend-react'), 'should detect frontend');
+      assert.ok(!result.detected.some(d => d.pack === 'backend-nodejs'), 'should NOT detect nodejs backend');
+      assert.ok(!result.comingSoon.some(d => d.pack === 'backend-nodejs'), 'should NOT show nodejs as coming soon');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('detects from subdirectory (1 level deep)', () => {
+    setup();
+    try {
+      const subdir = join(TMP, 'backend');
+      mkdirSync(subdir);
+      writeFileSync(join(subdir, 'build.gradle.kts'), 'id("io.micronaut.application")');
+      const result = detectStacks(TMP);
+      assert.ok(result.detected.some(d => d.pack === 'backend-micronaut'), 'should detect from subdir');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('includes reason string for each detection', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'build.gradle.kts'), 'id("io.micronaut.application")');
+      const result = detectStacks(TMP);
+      const match = result.detected.find(d => d.pack === 'backend-micronaut');
+      assert.ok(match.reason, 'should have a reason');
+      assert.ok(match.reason.length > 0, 'reason should not be empty');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('does not detect Kotlin without Micronaut', () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, 'build.gradle.kts'), `
+plugins {
+    kotlin("jvm") version "1.9.0"
+}
+dependencies {
+    implementation("io.ktor:ktor-server-core")
+}
+`);
+      const result = detectStacks(TMP);
+      assert.ok(!result.detected.some(d => d.pack === 'backend-micronaut'), 'should NOT detect micronaut');
+    } finally {
+      cleanup();
+    }
+  });
+});

package/lib/packs.js

@@ -0,0 +1,16 @@
+// Spartan AI Toolkit — Pack Definitions
+// Loads from YAML manifests in toolkit/packs/. Single source of truth.
+
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadManifests, detectCycles, toPacks } from './resolver.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKS_DIR = join(__dirname, '..', 'packs');
+
+const manifests = loadManifests(PACKS_DIR);
+detectCycles(manifests);
+
+const { PACKS, PACK_ORDER } = toPacks(manifests);
+
+export { PACKS, PACK_ORDER };

package/lib/resolver.js

@@ -0,0 +1,272 @@
+// Spartan AI Toolkit — Pack Resolver
+// Loads YAML manifests and resolves dependencies (BFS + cycle detection).
+
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { load } from 'js-yaml';
+
+/**
+ * Load all pack manifests from a directory.
+ * @param {string} packsDir - Path to toolkit/packs/
+ * @returns {Map<string, object>} Pack name → manifest object
+ */
+export function loadManifests(packsDir) {
+  const manifests = new Map();
+  for (const file of readdirSync(packsDir).filter(f => f.endsWith('.yaml'))) {
+    const raw = readFileSync(join(packsDir, file), 'utf-8');
+    const manifest = load(raw);
+    manifests.set(manifest.name, manifest);
+  }
+  return manifests;
+}
+
+/**
+ * Detect cycles using DFS.
+ * @param {Map<string, object>} manifests
+ * @throws {Error} If a cycle is found
+ */
+export function detectCycles(manifests) {
+  const visited = new Set();
+  const stack = new Set();
+
+  function dfs(name, path) {
+    if (stack.has(name)) {
+      throw new Error(`Cycle detected: ${[...path, name].join(' → ')}`);
+    }
+    if (visited.has(name)) return;
+    stack.add(name);
+    path.push(name);
+    const manifest = manifests.get(name);
+    if (manifest?.depends) {
+      for (const dep of manifest.depends) {
+        dfs(dep, [...path]);
+      }
+    }
+    stack.delete(name);
+    visited.add(name);
+  }
+
+  for (const name of manifests.keys()) {
+    dfs(name, []);
+  }
+}
+
+/**
+ * Resolve dependencies using BFS. Returns sorted pack list with core always first.
+ * @param {string[]} selected - Pack names the user picked
+ * @param {Map<string, object>} manifests - All loaded manifests
+ * @returns {string[]} Resolved + sorted pack names
+ */
+export function resolve(selected, manifests) {
+  const resolved = new Set();
+  const queue = [...selected];
+
+  while (queue.length > 0) {
+    const pack = queue.shift();
+    if (resolved.has(pack)) continue;
+    if (!manifests.has(pack)) {
+      throw new Error(`Unknown pack: '${pack}'`);
+    }
+    resolved.add(pack);
+    const manifest = manifests.get(pack);
+    if (manifest.depends) {
+      for (const dep of manifest.depends) {
+        if (!resolved.has(dep)) queue.push(dep);
+      }
+    }
+  }
+
+  // Core always included
+  resolved.add('core');
+
+  // Sort by priority, core always first
+  const sorted = [...resolved].sort((a, b) => {
+    const pa = manifests.get(a)?.priority ?? 999;
+    const pb = manifests.get(b)?.priority ?? 999;
+    return pa - pb;
+  });
+
+  return sorted;
+}
+
+/** Pack name aliases for backward compatibility. */
+export const ALIASES = {
+  backend: 'backend-micronaut',
+  frontend: 'frontend-react',
+};
+
+/**
+ * Resolve aliases in a list of pack names.
+ * @param {string[]} names - Pack names (may include old names)
+ * @returns {{ resolved: string[], warnings: string[] }}
+ */
+export function resolveAliases(names) {
+  const resolved = [];
+  const warnings = [];
+  for (const name of names) {
+    if (ALIASES[name]) {
+      resolved.push(ALIASES[name]);
+      warnings.push(`"${name}" is now "${ALIASES[name]}". Update your .spartan-packs file.`);
+    } else {
+      resolved.push(name);
+    }
+  }
+  return { resolved, warnings };
+}
+
+/**
+ * Convert manifests to the PACKS format used by assembler and CLI.
+ * @param {Map<string, object>} manifests
+ * @returns {{ PACKS: object, PACK_ORDER: string[] }}
+ */
+export function toPacks(manifests) {
+  const PACKS = {};
+  const allPacks = [...manifests.values()].sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999));
+
+  for (const m of allPacks) {
+    PACKS[m.name] = {
+      description: m.description,
+      category: m.category || null,
+      priority: m.priority ?? 999,
+      hidden: m.hidden || false,
+      comingSoon: m['coming-soon'] || false,
+      depends: m.depends || [],
+      commands: m.commands || [],
+      rules: m.rules || [],
+      skills: m.skills || [],
+      agents: m.agents || [],
+      claudeSections: m['claude-sections'] || [],
+    };
+  }
+
+  const PACK_ORDER = allPacks.map(m => m.name);
+  return { PACKS, PACK_ORDER };
+}
+
+// ── Community Pack Support ─────────────────────────────────────
+
+const KEBAB_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+
+/**
+ * Validate a community pack manifest.
+ * @param {object} manifest - The parsed YAML manifest
+ * @param {string} packDir - Root directory of the external pack (for file checks)
+ * @param {Set<string>} builtinNames - Names of built-in packs (collision check)
+ * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
+ */
+export function validatePack(manifest, packDir, builtinNames) {
+  const errors = [];
+  const warnings = [];
+
+  // Required fields
+  if (!manifest.name) {
+    errors.push('Missing required field: name');
+  }
+  if (!manifest.description) {
+    errors.push('Missing required field: description');
+  }
+
+  // Name format
+  if (manifest.name && !KEBAB_RE.test(manifest.name)) {
+    errors.push(`Pack name "${manifest.name}" must be kebab-case (e.g., "go-backend")`);
+  }
+
+  // Name collision
+  if (manifest.name && builtinNames.has(manifest.name)) {
+    errors.push(`Pack name "${manifest.name}" collides with a built-in pack`);
+  }
+
+  // Dependency check — deps must be either built-in or in the same external dir
+  if (manifest.depends) {
+    for (const dep of manifest.depends) {
+      if (!builtinNames.has(dep)) {
+        // Check if dep is another external pack in same dir
+        const depFile = join(packDir, 'packs', `${dep}.yaml`);
+        if (!existsSync(depFile)) {
+          errors.push(`Dependency "${dep}" is not a built-in pack and not found in pack directory`);
+        }
+      }
+    }
+  }
+
+  // File existence warnings (non-blocking)
+  if (manifest.commands) {
+    for (const cmd of manifest.commands) {
+      const cmdFile = join(packDir, 'commands', 'spartan', `${cmd}.md`);
+      if (!existsSync(cmdFile)) {
+        warnings.push(`Command file not found: commands/spartan/${cmd}.md`);
+      }
+    }
+  }
+  if (manifest.rules) {
+    for (const rule of manifest.rules) {
+      const ruleFile = join(packDir, 'rules', rule);
+      if (!existsSync(ruleFile)) {
+        warnings.push(`Rule file not found: rules/${rule}`);
+      }
+    }
+  }
+  if (manifest.skills) {
+    for (const skill of manifest.skills) {
+      const skillDir = join(packDir, 'skills', skill);
+      if (!existsSync(skillDir)) {
+        warnings.push(`Skill directory not found: skills/${skill}`);
+      }
+    }
+  }
+  if (manifest.agents) {
+    for (const agent of manifest.agents) {
+      const agentFile = join(packDir, 'agents', agent);
+      if (!existsSync(agentFile)) {
+        warnings.push(`Agent file not found: agents/${agent}`);
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/**
+ * Load and validate external packs from a community pack directory.
+ * Expected structure: packDir/packs/*.yaml
+ * @param {string} packDir - Root directory of external pack collection
+ * @param {Set<string>} builtinNames - Names of built-in packs
+ * @returns {{ loaded: Map<string, object>, errors: string[] }}
+ */
+export function loadExternalPacks(packDir, builtinNames) {
+  const loaded = new Map();
+  const errors = [];
+
+  const packsSubdir = join(packDir, 'packs');
+  if (!existsSync(packsSubdir)) {
+    return { loaded, errors };
+  }
+
+  let files;
+  try {
+    files = readdirSync(packsSubdir).filter(f => f.endsWith('.yaml'));
+  } catch {
+    return { loaded, errors };
+  }
+
+  for (const file of files) {
+    try {
+      const raw = readFileSync(join(packsSubdir, file), 'utf-8');
+      const manifest = load(raw);
+
+      const result = validatePack(manifest, packDir, builtinNames);
+      if (!result.valid) {
+        for (const err of result.errors) {
+          errors.push(`${file}: ${err}`);
+        }
+        continue;
+      }
+
+      loaded.set(manifest.name, manifest);
+    } catch (err) {
+      errors.push(`${file}: Failed to parse — ${err.message}`);
+    }
+  }
+
+  return { loaded, errors };
+}