serpentstack 0.2.4 → 0.2.6

package/lib/commands/stack-new.js

@@ -26,6 +26,22 @@ function checkCommand(cmd) {
   });
 }
 
+function getCommandVersion(cmd, args = ['--version']) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: 5000 }, (err, stdout) => {
+      if (err) resolve(null);
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+function parseVersion(versionStr) {
+  if (!versionStr) return null;
+  const match = versionStr.match(/(\d+)\.(\d+)/);
+  if (!match) return null;
+  return { major: parseInt(match[1]), minor: parseInt(match[2]) };
+}
+
 export async function stackNew(name) {
   const nameError = validateName(name);
   if (nameError) {
@@ -49,20 +65,38 @@ export async function stackNew(name) {
 
   const checks = [
     { cmd: 'git', label: 'git', url: 'https://git-scm.com/downloads' },
-    { cmd: 'python3', label: 'Python 3.12+', url: 'https://python.org/downloads' },
-    { cmd: 'node', label: 'Node 22+', url: 'https://nodejs.org' },
+    { cmd: 'python3', label: 'Python 3.12+', url: 'https://python.org/downloads', minMajor: 3, minMinor: 12 },
+    { cmd: 'node', label: 'Node 22+', url: 'https://nodejs.org', minMajor: 22, minMinor: 0 },
     { cmd: 'docker', label: 'Docker', url: 'https://docker.com/get-started' },
     { cmd: 'uv', label: 'uv (Python package manager)', url: 'https://docs.astral.sh/uv' },
   ];
 
-  let missing = [];
-  for (const { cmd, label, url } of checks) {
+  // Run all checks in parallel
+  const results = await Promise.all(checks.map(async ({ cmd, label, url, minMajor, minMinor }) => {
     const found = await checkCommand(cmd);
-    if (found) {
-      console.log(`  ${green('\u2713')} ${label}`);
+    if (!found) return { label, url, found: false };
+
+    // Version check if required
+    if (minMajor != null) {
+      const vStr = await getCommandVersion(cmd);
+      const ver = parseVersion(vStr);
+      if (ver && (ver.major < minMajor || (ver.major === minMajor && ver.minor < minMinor))) {
+        return { label, url, found: true, versionOk: false, version: vStr };
+      }
+    }
+    return { label, found: true, versionOk: true };
+  }));
+
+  let missing = [];
+  for (const r of results) {
+    if (!r.found) {
+      console.log(`  ${dim('\u2022')} ${dim(r.label)} ${dim(`\u2014 install: ${r.url}`)}`);
+      missing.push(r.label);
+    } else if (r.versionOk === false) {
+      console.log(`  ${yellow('\u25B3')} ${r.label} ${dim(`\u2014 found ${r.version}, need newer version`)}`);
+      missing.push(r.label);
     } else {
-      console.log(`  ${dim('\u2022')} ${dim(label)} ${dim(`\u2014 install: ${url}`)}`);
-      missing.push(label);
+      console.log(`  ${green('\u2713')} ${r.label}`);
     }
   }
   console.log();
@@ -85,7 +119,8 @@ export async function stackNew(name) {
   const spin = spinner(`Downloading SerpentStack template...`);
   try {
     await cloneRepo(dest);
-    spin.stop(success(`Template cloned into ${green(name)}/`));
+    spin.stop();
+    success(`Template cloned into ${green(name)}/`);
   } catch (err) {
     spin.stop();
     error(err.message);

package/lib/utils/config.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CONFIG_PATH = '.openclaw/config.json';
+
+/**
+ * Default config structure:
+ * {
+ *   project: { name, language, framework, devCmd, testCmd, conventions },
+ *   agents: {
+ *     "log-watcher": { enabled: true, model: "anthropic/claude-haiku-4-20250414" },
+ *     ...
+ *   }
+ * }
+ */
+
+/**
+ * Read the config file. Returns null if it doesn't exist.
+ */
+export function readConfig(projectDir) {
+  const configPath = join(projectDir, CONFIG_PATH);
+  if (!existsSync(configPath)) return null;
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.error(`  \x1b[33m\u25B3\x1b[0m .openclaw/config.json has invalid JSON — ignoring. Fix it or delete it to regenerate.`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Write config to .openclaw/config.json
+ */
+export function writeConfig(projectDir, config) {
+  const configPath = join(projectDir, CONFIG_PATH);
+  mkdirSync(join(projectDir, '.openclaw'), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Detect if this is a SerpentStack template project and return defaults.
+ * Returns null if not a template project.
+ */
+export function detectTemplateDefaults(projectDir) {
+  const makefile = join(projectDir, 'Makefile');
+  if (!existsSync(makefile)) return null;
+
+  try {
+    const content = readFileSync(makefile, 'utf8');
+    // SerpentStack Makefile: must have 'make verify' AND either 'uv run' or 'uvicorn'
+    if (!content.includes('make verify')) return null;
+    if (!content.includes('uv run') && !content.includes('uvicorn')) return null;
+
+    // It's a SerpentStack template project — return smart defaults
+    const defaults = {
+      language: 'Python + TypeScript',
+      framework: 'FastAPI + React',
+      devCmd: 'make dev',
+      testCmd: 'make verify',
+      conventions: 'Services flush, routes commit. Domain returns, not exceptions. Real Postgres in tests.',
+    };
+
+    // Try to detect project name from scripts/init.py or package.json
+    const pkgPath = join(projectDir, 'frontend', 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (pkg.name && pkg.name !== 'frontend') defaults.name = pkg.name;
+      } catch { /* ignore */ }
+    }
+
+    return defaults;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a default agent config entry from an AGENT.md's parsed meta.
+ */
+export function defaultAgentConfig(meta) {
+  return {
+    enabled: true,
+    model: meta.model || 'anthropic/claude-haiku-4-20250414',
+  };
+}
+
+/**
+ * Get the effective model for an agent, respecting config overrides.
+ */
+export function getEffectiveModel(agentName, agentMeta, config) {
+  if (config?.agents?.[agentName]?.model) {
+    return config.agents[agentName].model;
+  }
+  return agentMeta.model || 'anthropic/claude-haiku-4-20250414';
+}
+
+/**
+ * Check if an agent is enabled in the config.
+ */
+export function isAgentEnabled(agentName, config) {
+  if (!config?.agents?.[agentName]) return true; // enabled by default
+  return config.agents[agentName].enabled !== false;
+}

package/lib/utils/fs-helpers.js

@@ -19,7 +19,7 @@ export function safeWrite(destPath, content, { force = false } = {}) {
     // Don't overwrite if content is identical
     try {
       const existing = readFileSync(destPath, 'utf8');
-      if (existing === content) return 'skipped';
+      if (existing === content) return 'unchanged';
     } catch { /* proceed with overwrite */ }
 
     writeFileSync(destPath, content, 'utf8');

package/lib/utils/models.js

@@ -0,0 +1,156 @@
+import { execFile } from 'node:child_process';
+
+/**
+ * Detect all available models: local (Ollama) and cloud (via OpenClaw auth).
+ * Local models are preferred for persistent agents — they're free and fast.
+ * Cloud models require API keys and cost money per token.
+ *
+ * Returns { local: [...], cloud: [...], hasApiKey: bool }
+ */
+export async function detectModels() {
+  const [ollamaModels, openclawInfo] = await Promise.all([
+    detectOllamaModels(),
+    detectOpenClawAuth(),
+  ]);
+
+  return {
+    local: ollamaModels,
+    cloud: openclawInfo.models,
+    hasApiKey: openclawInfo.hasApiKey,
+  };
+}
+
+/**
+ * Detect locally installed Ollama models with parameter counts.
+ * Parses `ollama list` output.
+ */
+async function detectOllamaModels() {
+  try {
+    const output = await execAsync('ollama', ['list']);
+    const lines = output.trim().split('\n');
+    if (lines.length < 2) return []; // header only
+
+    // Parse header to find column positions
+    const header = lines[0];
+    const nameEnd = header.indexOf('ID');
+    const sizeStart = header.indexOf('SIZE');
+
+    return lines.slice(1).map(line => {
+      if (!line.trim()) return null;
+
+      const name = line.slice(0, nameEnd).trim();
+      if (!name) return null;
+
+      // Extract size (e.g., "4.7 GB", "1.3 GB")
+      const sizeStr = sizeStart >= 0 ? line.slice(sizeStart).trim().split(/\s{2,}/)[0] : '';
+
+      // Estimate parameter count from model name (e.g., "llama3.2:3b", "qwen2.5-coder:7b")
+      const paramMatch = name.match(/[:\-](\d+\.?\d*)[bB]/);
+      const params = paramMatch ? paramMatch[1] + 'B' : guessParams(name, sizeStr);
+
+      const shortName = name.replace(':latest', '');
+
+      return {
+        id: `ollama/${shortName}`,
+        name: shortName,
+        params,
+        size: sizeStr,
+        tier: 'local',
+      };
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Guess parameter count from file size if not in the name.
+ * Rough heuristic: ~0.5GB per billion parameters for Q4 quantization.
+ */
+function guessParams(name, sizeStr) {
+  const gbMatch = sizeStr.match(/([\d.]+)\s*GB/i);
+  if (gbMatch) {
+    const gb = parseFloat(gbMatch[1]);
+    const billions = Math.round(gb * 2); // Q4 ≈ 0.5GB/B
+    if (billions > 0) return `~${billions}B`;
+  }
+  return '';
+}
+
+/**
+ * Check OpenClaw for configured models and API key status.
+ */
+async function detectOpenClawAuth() {
+  const result = { models: [], hasApiKey: false };
+
+  try {
+    // Check if any API key is configured via openclaw models status
+    const status = await execAsync('openclaw', ['models', 'status']);
+
+    // Look for "api_key" or "configured" in the output
+    if (status.includes('api_key') || status.includes('configured')) {
+      result.hasApiKey = true;
+    }
+
+    // Get the model catalog for cloud options
+    const list = await execAsync('openclaw', ['models', 'list', '--json']);
+    try {
+      const models = JSON.parse(list);
+      if (Array.isArray(models)) {
+        result.models = models
+          .filter(m => m.available && !m.local)
+          .map(m => ({
+            id: m.key || m.name,
+            name: modelShortName(m.key || m.name),
+            provider: (m.key || '').split('/')[0] || 'unknown',
+            tier: 'cloud',
+          }));
+      }
+    } catch {
+      // Fall back to text parsing
+      const text = await execAsync('openclaw', ['models', 'list']);
+      const lines = text.trim().split('\n').filter(l => l.trim() && !l.startsWith('Model'));
+      result.models = lines.map(l => {
+        const id = l.trim().split(/\s+/)[0];
+        if (!id || id.length < 3) return null;
+        return { id, name: modelShortName(id), provider: id.split('/')[0], tier: 'cloud' };
+      }).filter(Boolean);
+    }
+  } catch {
+    // OpenClaw not installed or no models configured — use defaults
+    result.models = [
+      { id: 'anthropic/claude-haiku-4-20250414', name: 'Haiku', provider: 'anthropic', tier: 'cloud' },
+      { id: 'anthropic/claude-sonnet-4-20250514', name: 'Sonnet', provider: 'anthropic', tier: 'cloud' },
+    ];
+  }
+
+  return result;
+}
+
+/**
+ * Short display name for a model ID.
+ */
+export function modelShortName(model) {
+  if (!model) return 'unknown';
+  // Anthropic models
+  if (model.startsWith('anthropic/')) {
+    if (model.includes('haiku')) return 'Haiku';
+    if (model.includes('sonnet')) return 'Sonnet';
+    if (model.includes('opus')) return 'Opus';
+    return model.slice('anthropic/'.length);
+  }
+  // Ollama models
+  if (model.startsWith('ollama/')) return model.slice('ollama/'.length);
+  // Other: strip provider prefix
+  if (model.includes('/')) return model.split('/').pop();
+  return model;
+}
+
+function execAsync(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: 5000 }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout);
+    });
+  });
+}

package/lib/utils/ui.js

@@ -17,10 +17,10 @@ const MAGENTA = c(35);
 const CYAN = c(36);
 const BG_DIM = c(100);
 
-export const info = (msg) => console.log(`${CYAN}\u2022${RESET} ${msg}`);
-export const success = (msg) => console.log(`${GREEN}\u2713${RESET} ${msg}`);
-export const warn = (msg) => console.log(`${YELLOW}\u25B3${RESET} ${msg}`);
-export const error = (msg) => console.error(`${RED}\u2717${RESET} ${msg}`);
+export const info = (msg) => console.log(`  ${CYAN}\u2022${RESET} ${msg}`);
+export const success = (msg) => console.log(`  ${GREEN}\u2713${RESET} ${msg}`);
+export const warn = (msg) => console.log(`  ${YELLOW}\u25B3${RESET} ${msg}`);
+export const error = (msg) => console.error(`  ${RED}\u2717${RESET} ${msg}`);
 export const dim = (msg) => `${DIM}${msg}${RESET}`;
 export const bold = (msg) => `${BOLD}${msg}${RESET}`;
 export const green = (msg) => `${GREEN}${msg}${RESET}`;
@@ -147,5 +147,5 @@ export function fileStatus(path, status, detail) {
 }
 
 function stripAnsi(str) {
-  return str.replace(/\x1b\[\d+m/g, '');
+  return str.replace(/\x1b\[[\d;]*m/g, '');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serpentstack",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "CLI for SerpentStack — AI-driven development standards with project-specific skills and persistent agents",
   "type": "module",
   "bin": {