serpentstack 0.2.9 → 0.2.10

package/lib/commands/persistent.js

@@ -18,6 +18,7 @@ import {
 import {
   readConfig,
   writeConfig,
+  detectProjectDefaults,
   detectTemplateDefaults,
   getEffectiveModel,
   isAgentEnabled,
@@ -352,18 +353,19 @@ export async function persistent({ stop = false, reconfigure = false } = {}) {
 
   try {
     // ── Project configuration ──
-    const templateDefaults = detectTemplateDefaults(projectDir);
+    const detected = detectProjectDefaults(projectDir);
+    const template = detectTemplateDefaults(projectDir);
     const existing = config.project || {};
     const defaults = {
-      name: existing.name || templateDefaults?.name || '',
-      language: existing.language || templateDefaults?.language || '',
-      framework: existing.framework || templateDefaults?.framework || '',
-      devCmd: existing.devCmd || templateDefaults?.devCmd || '',
-      testCmd: existing.testCmd || templateDefaults?.testCmd || '',
-      conventions: existing.conventions || templateDefaults?.conventions || '',
+      name: existing.name || template?.name || detected.name,
+      language: existing.language || template?.language || detected.language,
+      framework: existing.framework || template?.framework || detected.framework,
+      devCmd: existing.devCmd || template?.devCmd || detected.devCmd,
+      testCmd: existing.testCmd || template?.testCmd || detected.testCmd,
+      conventions: existing.conventions || template?.conventions || detected.conventions,
     };
 
-    if (templateDefaults && !existing.name) {
+    if (template && !existing.name) {
       info('Detected SerpentStack template — defaults pre-filled');
       console.log();
     }

package/lib/commands/skills-init.js

@@ -2,7 +2,7 @@ import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { downloadFile } from '../utils/github.js';
 import { safeWrite } from '../utils/fs-helpers.js';
-import { readConfig, writeConfig, detectTemplateDefaults, defaultAgentConfig } from '../utils/config.js';
+import { readConfig, writeConfig, detectProjectDefaults, detectTemplateDefaults, defaultAgentConfig } from '../utils/config.js';
 import { parseAgentMd, discoverAgents } from '../utils/agent-utils.js';
 import { info, success, warn, error, spinner, bold, dim, green, cyan, divider, printBox, printPrompt, printHeader, fileStatus } from '../utils/ui.js';
 
@@ -87,15 +87,18 @@ export async function skillsInit({ force = false } = {}) {
   // Generate default config.json if it doesn't exist
   const projectDir = process.cwd();
   if (!readConfig(projectDir)) {
-    const templateDefaults = detectTemplateDefaults(projectDir) || {};
+    // Auto-detect project info from filesystem
+    const detected = detectProjectDefaults(projectDir);
+    // SerpentStack template overrides (more specific)
+    const template = detectTemplateDefaults(projectDir);
     const config = {
       project: {
-        name: templateDefaults.name || '',
-        language: templateDefaults.language || '',
-        framework: templateDefaults.framework || '',
-        devCmd: templateDefaults.devCmd || '',
-        testCmd: templateDefaults.testCmd || '',
-        conventions: templateDefaults.conventions || '',
+        name: template?.name || detected.name,
+        language: template?.language || detected.language,
+        framework: template?.framework || detected.framework,
+        devCmd: template?.devCmd || detected.devCmd,
+        testCmd: template?.testCmd || detected.testCmd,
+        conventions: template?.conventions || detected.conventions,
       },
       agents: {},
     };

package/lib/utils/config.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
 
 const CONFIG_PATH = '.openclaw/config.json';
 
@@ -28,7 +28,7 @@ export function readConfig(projectDir) {
     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.`);
+      console.error(`  \x1b[33m△\x1b[0m .openclaw/config.json has invalid JSON — ignoring. Fix it or delete it to regenerate.`);
     }
     return null;
   }
@@ -43,9 +43,30 @@ export function writeConfig(projectDir, config) {
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
 }
 
+// ─── Project Detection ───────────────────────────────────────
+
+/**
+ * Detect project defaults by inspecting the filesystem.
+ * Works for ANY project — detects name, language, framework, commands.
+ * Always returns an object with every field populated (never empty strings).
+ * When nothing can be detected, returns sensible "fill me in" defaults
+ * that read naturally in the config file and prompt the user to update.
+ */
+export function detectProjectDefaults(projectDir) {
+  return {
+    name: detectProjectName(projectDir),
+    language: detectLanguage(projectDir),
+    framework: detectFramework(projectDir),
+    devCmd: detectDevCmd(projectDir),
+    testCmd: detectTestCmd(projectDir),
+    conventions: detectConventions(projectDir),
+  };
+}
+
 /**
- * Detect if this is a SerpentStack template project and return defaults.
- * Returns null if not a template project.
+ * Detect if this is a SerpentStack template project and return overrides.
+ * Returns null if not a template project. When non-null, these values
+ * take priority over the generic detection.
  */
 export function detectTemplateDefaults(projectDir) {
   const makefile = join(projectDir, 'Makefile');
@@ -57,7 +78,7 @@ export function detectTemplateDefaults(projectDir) {
     if (!/^verify:/m.test(content)) return null;
     if (!content.includes('uv run')) return null;
 
-    // It's a SerpentStack template project — return smart defaults
+    // It's a SerpentStack template project — return specific defaults
     const defaults = {
       language: 'Python + TypeScript',
       framework: 'FastAPI + React',
@@ -66,7 +87,7 @@ export function detectTemplateDefaults(projectDir) {
       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
+    // Try to detect project name from frontend/package.json
     const pkgPath = join(projectDir, 'frontend', 'package.json');
     if (existsSync(pkgPath)) {
       try {
@@ -81,6 +102,209 @@ export function detectTemplateDefaults(projectDir) {
   }
 }
 
+// ─── Detection helpers ───────────────────────────────────────
+
+function detectProjectName(projectDir) {
+  // 1. package.json name
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      if (pkg.name && pkg.name !== 'unnamed') return pkg.name;
+    } catch { /* ignore */ }
+  }
+
+  // 2. pyproject.toml name
+  const pyprojectPath = join(projectDir, 'pyproject.toml');
+  if (existsSync(pyprojectPath)) {
+    try {
+      const content = readFileSync(pyprojectPath, 'utf8');
+      const match = content.match(/^name\s*=\s*"([^"]+)"/m);
+      if (match) return match[1];
+    } catch { /* ignore */ }
+  }
+
+  // 3. Cargo.toml name
+  const cargoPath = join(projectDir, 'Cargo.toml');
+  if (existsSync(cargoPath)) {
+    try {
+      const content = readFileSync(cargoPath, 'utf8');
+      const match = content.match(/^name\s*=\s*"([^"]+)"/m);
+      if (match) return match[1];
+    } catch { /* ignore */ }
+  }
+
+  // 4. Fall back to directory name
+  return basename(projectDir);
+}
+
+function detectLanguage(projectDir) {
+  const langs = [];
+  if (existsSync(join(projectDir, 'pyproject.toml')) || existsSync(join(projectDir, 'requirements.txt')) || existsSync(join(projectDir, 'setup.py'))) {
+    langs.push('Python');
+  }
+  if (existsSync(join(projectDir, 'tsconfig.json'))) {
+    langs.push('TypeScript');
+  } else if (existsSync(join(projectDir, 'package.json'))) {
+    langs.push('JavaScript');
+  }
+  if (existsSync(join(projectDir, 'go.mod'))) {
+    langs.push('Go');
+  }
+  if (existsSync(join(projectDir, 'Cargo.toml'))) {
+    langs.push('Rust');
+  }
+  if (existsSync(join(projectDir, 'pom.xml')) || existsSync(join(projectDir, 'build.gradle'))) {
+    langs.push('Java');
+  }
+  if (existsSync(join(projectDir, 'Gemfile'))) {
+    langs.push('Ruby');
+  }
+  // If nothing detected, use SerpentStack template default since
+  // that's the most common use case (user just ran `stack new`)
+  return langs.length > 0 ? langs.join(' + ') : 'Python + TypeScript';
+}
+
+function detectFramework(projectDir) {
+  const frameworks = [];
+
+  // Python frameworks
+  const pyFiles = [join(projectDir, 'pyproject.toml'), join(projectDir, 'requirements.txt')];
+  for (const f of pyFiles) {
+    if (!existsSync(f)) continue;
+    try {
+      const content = readFileSync(f, 'utf8');
+      if (content.includes('fastapi')) frameworks.push('FastAPI');
+      else if (content.includes('django')) frameworks.push('Django');
+      else if (content.includes('flask')) frameworks.push('Flask');
+      break;
+    } catch { /* ignore */ }
+  }
+
+  // JS/TS frameworks
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps['next']) frameworks.push('Next.js');
+      else if (allDeps['react']) frameworks.push('React');
+      else if (allDeps['vue']) frameworks.push('Vue');
+      else if (allDeps['svelte'] || allDeps['@sveltejs/kit']) frameworks.push('Svelte');
+      else if (allDeps['express']) frameworks.push('Express');
+    } catch { /* ignore */ }
+  }
+
+  // Go frameworks
+  const goModPath = join(projectDir, 'go.mod');
+  if (existsSync(goModPath)) {
+    try {
+      const content = readFileSync(goModPath, 'utf8');
+      if (content.includes('gin-gonic')) frameworks.push('Gin');
+      else if (content.includes('labstack/echo')) frameworks.push('Echo');
+      else if (content.includes('gofiber')) frameworks.push('Fiber');
+      else frameworks.push('Go');
+    } catch { /* ignore */ }
+  }
+
+  // Ruby
+  const gemfilePath = join(projectDir, 'Gemfile');
+  if (existsSync(gemfilePath)) {
+    try {
+      const content = readFileSync(gemfilePath, 'utf8');
+      if (content.includes('rails')) frameworks.push('Rails');
+      else if (content.includes('sinatra')) frameworks.push('Sinatra');
+    } catch { /* ignore */ }
+  }
+
+  return frameworks.length > 0 ? frameworks.join(' + ') : 'FastAPI + React';
+}
+
+function detectDevCmd(projectDir) {
+  // Makefile targets
+  const makefile = join(projectDir, 'Makefile');
+  if (existsSync(makefile)) {
+    try {
+      const content = readFileSync(makefile, 'utf8');
+      if (/^dev:/m.test(content)) return 'make dev';
+      if (/^start:/m.test(content)) return 'make start';
+      if (/^run:/m.test(content)) return 'make run';
+      if (/^serve:/m.test(content)) return 'make serve';
+    } catch { /* ignore */ }
+  }
+
+  // package.json scripts
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      const scripts = pkg.scripts || {};
+      if (scripts.dev) return 'npm run dev';
+      if (scripts.start) return 'npm start';
+      if (scripts.serve) return 'npm run serve';
+    } catch { /* ignore */ }
+  }
+
+  // Python
+  if (existsSync(join(projectDir, 'manage.py'))) return 'python manage.py runserver';
+  if (existsSync(join(projectDir, 'pyproject.toml'))) return 'uv run python -m app';
+
+  return 'make dev';
+}
+
+function detectTestCmd(projectDir) {
+  // Makefile targets
+  const makefile = join(projectDir, 'Makefile');
+  if (existsSync(makefile)) {
+    try {
+      const content = readFileSync(makefile, 'utf8');
+      if (/^verify:/m.test(content)) return 'make verify';
+      if (/^test:/m.test(content)) return 'make test';
+      if (/^check:/m.test(content)) return 'make check';
+    } catch { /* ignore */ }
+  }
+
+  // package.json scripts
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      const scripts = pkg.scripts || {};
+      if (scripts.test && scripts.test !== 'echo "Error: no test specified" && exit 1') {
+        return 'npm test';
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Python
+  if (existsSync(join(projectDir, 'pyproject.toml')) || existsSync(join(projectDir, 'setup.py'))) {
+    return 'pytest';
+  }
+
+  // Go
+  if (existsSync(join(projectDir, 'go.mod'))) return 'go test ./...';
+
+  // Rust
+  if (existsSync(join(projectDir, 'Cargo.toml'))) return 'cargo test';
+
+  return 'make verify';
+}
+
+function detectConventions(projectDir) {
+  // Check if this looks like a SerpentStack template (has the standard Makefile)
+  const makefile = join(projectDir, 'Makefile');
+  if (existsSync(makefile)) {
+    try {
+      const content = readFileSync(makefile, 'utf8');
+      if (/^verify:/m.test(content) && content.includes('uv run')) {
+        return 'Services flush, routes commit. Domain returns, not exceptions. Real Postgres in tests.';
+      }
+    } catch { /* ignore */ }
+  }
+
+  return 'Follow existing patterns. Match the style of surrounding code.';
+}
+
 /**
  * Build a default agent config entry from an AGENT.md's parsed meta.
  */

package/package.json

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