coder-config 0.41.27 → 0.41.30

package/lib/constants.js

@@ -2,7 +2,7 @@
  * Constants and tool path configurations
  */
 
-const VERSION = '0.41.27';
+const VERSION = '0.41.30';
 
 // Tool-specific path configurations
 const TOOL_PATHS = {

package/lib/workstreams.js

@@ -628,6 +628,253 @@ function workstreamCheckPath(installDir, targetPath, silent = false) {
   return isWithin;
 }
 
+/**
+ * Generate rules/context from project repositories using Claude Code
+ * Runs `claude -p` to analyze repos and generate smart context
+ */
+async function generateRulesWithClaude(projects) {
+  if (!projects || projects.length === 0) {
+    return '';
+  }
+
+  const { execFileSync } = require('child_process');
+
+  const projectPaths = projects.map(p =>
+    path.resolve(p.replace(/^~/, process.env.HOME || ''))
+  );
+
+  const projectList = projectPaths.map(p => `- ${p}`).join('\n');
+
+  const prompt = `Analyze these project repositories and generate concise workstream context rules for an AI coding assistant. Focus on:
+1. What each project does (brief description)
+2. Key technologies and frameworks used
+3. How the projects relate to each other (if multiple)
+4. Any important conventions or patterns to follow
+
+Projects:
+${projectList}
+
+Output markdown suitable for injecting into an AI assistant's context. Keep it concise (under 500 words). Do not include code blocks or examples - just descriptions and guidelines.`;
+
+  try {
+    // Run claude -p with the prompt using execFileSync (safer than exec)
+    const result = execFileSync('claude', ['-p', prompt], {
+      cwd: projectPaths[0],
+      encoding: 'utf8',
+      timeout: 60000, // 60 second timeout
+      maxBuffer: 1024 * 1024, // 1MB buffer
+    });
+
+    return result.trim();
+  } catch (error) {
+    console.error('Claude generation failed:', error.message);
+    // Fall back to simple generation
+    return generateRulesFromRepos(projects);
+  }
+}
+
+/**
+ * Generate rules/context from project repositories
+ * Reads README.md, package.json, CLAUDE.md, etc. to create a summary
+ */
+function generateRulesFromRepos(projects) {
+  if (!projects || projects.length === 0) {
+    return '';
+  }
+
+  const lines = [];
+  lines.push('# Workstream Context');
+  lines.push('');
+  lines.push('## Repositories');
+  lines.push('');
+
+  for (const projectPath of projects) {
+    const absPath = path.resolve(projectPath.replace(/^~/, process.env.HOME || ''));
+    const name = path.basename(absPath);
+
+    lines.push(`### ${name}`);
+    lines.push('');
+
+    // Check for CLAUDE.md first (most relevant for Claude context)
+    const claudeMdPath = path.join(absPath, 'CLAUDE.md');
+    if (fs.existsSync(claudeMdPath)) {
+      try {
+        const content = fs.readFileSync(claudeMdPath, 'utf8');
+        // Extract first section or summary
+        const firstSection = extractFirstSection(content);
+        if (firstSection) {
+          lines.push(firstSection.trim());
+          lines.push('');
+          continue; // CLAUDE.md is comprehensive, skip other files
+        }
+      } catch (e) {
+        // Ignore read errors
+      }
+    }
+
+    // Check for package.json (JavaScript/TypeScript projects)
+    const packageJsonPath = path.join(absPath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (pkg.description) {
+          lines.push(`**Description:** ${pkg.description}`);
+          lines.push('');
+        }
+        const deps = Object.keys(pkg.dependencies || {});
+        const devDeps = Object.keys(pkg.devDependencies || {});
+        if (deps.length > 0 || devDeps.length > 0) {
+          const keyDeps = [...deps, ...devDeps].filter(d =>
+            ['react', 'vue', 'angular', 'next', 'express', 'fastify', 'koa',
+             'typescript', 'prisma', 'drizzle', 'mongoose', 'sequelize',
+             'tailwindcss', 'vite', 'webpack', 'jest', 'vitest', 'mocha'].includes(d)
+          );
+          if (keyDeps.length > 0) {
+            lines.push(`**Stack:** ${keyDeps.join(', ')}`);
+            lines.push('');
+          }
+        }
+      } catch (e) {
+        // Ignore parse errors
+      }
+    }
+
+    // Check for pyproject.toml (Python projects)
+    const pyprojectPath = path.join(absPath, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath)) {
+      try {
+        const content = fs.readFileSync(pyprojectPath, 'utf8');
+        const descMatch = content.match(/description\s*=\s*"([^"]+)"/);
+        if (descMatch) {
+          lines.push(`**Description:** ${descMatch[1]}`);
+          lines.push('');
+        }
+        // Detect common Python frameworks
+        const frameworks = [];
+        if (content.includes('fastapi')) frameworks.push('FastAPI');
+        if (content.includes('django')) frameworks.push('Django');
+        if (content.includes('flask')) frameworks.push('Flask');
+        if (content.includes('sqlalchemy')) frameworks.push('SQLAlchemy');
+        if (content.includes('pytest')) frameworks.push('pytest');
+        if (frameworks.length > 0) {
+          lines.push(`**Stack:** ${frameworks.join(', ')}`);
+          lines.push('');
+        }
+      } catch (e) {
+        // Ignore read errors
+      }
+    }
+
+    // Check for README.md
+    const readmePath = path.join(absPath, 'README.md');
+    if (fs.existsSync(readmePath)) {
+      try {
+        const content = fs.readFileSync(readmePath, 'utf8');
+        // Extract first paragraph or description
+        const firstPara = extractFirstParagraph(content);
+        if (firstPara && firstPara.length > 20) {
+          lines.push(firstPara.trim());
+          lines.push('');
+        }
+      } catch (e) {
+        // Ignore read errors
+      }
+    }
+
+    // Check for Cargo.toml (Rust projects)
+    const cargoPath = path.join(absPath, 'Cargo.toml');
+    if (fs.existsSync(cargoPath)) {
+      try {
+        const content = fs.readFileSync(cargoPath, 'utf8');
+        const descMatch = content.match(/description\s*=\s*"([^"]+)"/);
+        if (descMatch) {
+          lines.push(`**Description:** ${descMatch[1]}`);
+          lines.push('');
+        }
+        lines.push('**Language:** Rust');
+        lines.push('');
+      } catch (e) {
+        // Ignore read errors
+      }
+    }
+
+    // Check for go.mod (Go projects)
+    const goModPath = path.join(absPath, 'go.mod');
+    if (fs.existsSync(goModPath)) {
+      lines.push('**Language:** Go');
+      lines.push('');
+    }
+
+    // If nothing was found, just note the path
+    if (lines[lines.length - 1] === '' && lines[lines.length - 2] === `### ${name}`) {
+      lines.push(`*Project at ${absPath.replace(process.env.HOME || '', '~')}*`);
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n').trim();
+}
+
+/**
+ * Extract first meaningful section from markdown
+ */
+function extractFirstSection(content) {
+  const lines = content.split('\n');
+  let result = [];
+  let inSection = false;
+  let lineCount = 0;
+
+  for (const line of lines) {
+    // Skip initial title
+    if (!inSection && line.startsWith('# ')) {
+      inSection = true;
+      continue;
+    }
+    if (inSection) {
+      // Stop at next heading or after reasonable amount of content
+      if (line.startsWith('## ') && lineCount > 3) break;
+      if (lineCount > 15) break;
+      result.push(line);
+      if (line.trim()) lineCount++;
+    }
+  }
+
+  return result.join('\n').trim();
+}
+
+/**
+ * Extract first paragraph from README
+ */
+function extractFirstParagraph(content) {
+  const lines = content.split('\n');
+  let result = [];
+  let started = false;
+  let emptyLineCount = 0;
+
+  for (const line of lines) {
+    // Skip badges, titles, and empty lines at start
+    if (!started) {
+      if (line.startsWith('#') || line.startsWith('![') || line.startsWith('[!') || !line.trim()) {
+        continue;
+      }
+      started = true;
+    }
+
+    if (started) {
+      if (!line.trim()) {
+        emptyLineCount++;
+        if (emptyLineCount > 1) break;
+      } else {
+        emptyLineCount = 0;
+        result.push(line);
+        if (result.length > 5) break;
+      }
+    }
+  }
+
+  return result.join(' ').replace(/\s+/g, ' ').trim();
+}
+
 module.exports = {
   getWorkstreamsPath,
   loadWorkstreams,
@@ -650,4 +897,6 @@ module.exports = {
   workstreamInstallHookCodex,
   workstreamDeactivate,
   workstreamCheckPath,
+  generateRulesFromRepos,
+  generateRulesWithClaude,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-config",
-  "version": "0.41.27",
+  "version": "0.41.30",
   "description": "Configuration manager for AI coding tools - Claude Code, Gemini CLI, Codex CLI, Antigravity. Manage MCPs, rules, permissions, memory, and workstreams.",
   "author": "regression.io",
   "main": "config-loader.js",