contextos-agents 1.5.0 → 1.6.1

package/.agents/adapters/cursor/export.js

@@ -22,42 +22,36 @@ function getSkillGlobsAndFlags(skillName) {
     return { globs: '', alwaysApply: true };
   }
 
-  const FRONTEND_SKILLS = [
-    'react', 'nextjs', 'typescript', 'ui-ux-pro', 'impeccable-design',
-    'ui-design', 'ux-design', 'web-accessibility', 'brutalist-design',
-    'minimalist-design', 'soft-design', 'redesign-audit', 'react-best-practices',
-  ];
-  if (FRONTEND_SKILLS.includes(skillName)) {
-    return { globs: '**/*.{ts,tsx,js,jsx,css,scss,html}', alwaysApply: false };
-  }
-
-  const BACKEND_SKILLS = ['system-design', 'node', 'nestjs', 'microservices', 'ddd'];
-  if (BACKEND_SKILLS.includes(skillName)) {
-    return { globs: '**/*.{ts,js,json,prisma,sql}', alwaysApply: false };
-  }
-
-  if (skillName === 'database') {
-    return { globs: '**/*.{prisma,sql,sqlite,db,drizzle.config.*}', alwaysApply: false };
-  }
-
-  if (skillName === 'docker') {
-    return { globs: '**/Dockerfile*,**/docker-compose*.{yml,yaml}', alwaysApply: false };
-  }
-
-  if (skillName === 'testing') {
-    return { globs: '**/*.{test,spec}.{ts,js,tsx,jsx},vitest.config.*,jest.config.*', alwaysApply: false };
-  }
-
-  if (skillName === 'state-management') {
-    return { globs: '**/*{store,state,slice,reducer,atom}*.{ts,js,tsx,jsx}', alwaysApply: false };
-  }
-
-  if (skillName === 'performance' || skillName === 'vercel-optimize') {
-    return { globs: '**/*.{ts,tsx,js,jsx,json}', alwaysApply: false };
-  }
-
-  if (skillName === 'fastapi') {
-    return { globs: '**/*.{py,requirements.txt,Pipfile,pyproject.toml}', alwaysApply: false };
+  // Precise surgical globs mapping to prevent context flooding
+  const GLOB_MAP = {
+    'react': '**/*.{tsx,jsx}',
+    'react-best-practices': '**/*.{tsx,jsx}',
+    'nextjs': 'app/**/*,pages/**/*,next.config.*',
+    'typescript': '**/*.{ts,tsx}',
+    'ui-design': '**/*.{tsx,jsx,css,scss}',
+    'ui-ux-pro': '**/*.{tsx,jsx,css,scss}',
+    'ux-design': '**/*.{tsx,jsx}',
+    'impeccable-design': '**/*.{tsx,jsx,css,scss}',
+    'brutalist-design': '**/*.{tsx,jsx,css,scss}',
+    'minimalist-design': '**/*.{tsx,jsx,css,scss}',
+    'soft-design': '**/*.{tsx,jsx,css,scss}',
+    'redesign-audit': '**/*.{tsx,jsx,css,scss}',
+    'web-accessibility': '**/*.{tsx,jsx,html}',
+    'ddd': '**/domain/**/*,**/entities/**/*,**/aggregates/**/*',
+    'microservices': '**/services/**/*,docker-compose.*,**/gateway/**/*',
+    'nestjs': '**/*.module.ts,**/*.controller.ts,**/*.service.ts,nest-cli.json',
+    'node': '**/*.{ts,js}',
+    'database': '**/*.{prisma,sql,sqlite,db,drizzle.config.*}',
+    'docker': '**/Dockerfile*,**/docker-compose*.{yml,yaml}',
+    'testing': '**/*.{test,spec}.{ts,js,tsx,jsx},vitest.config.*,jest.config.*',
+    'state-management': '**/*{store,state,slice,reducer,atom}*.{ts,js,tsx,jsx}',
+    'performance': '**/*.{ts,tsx,js,jsx,json}',
+    'vercel-optimize': '**/*.{ts,tsx,js,jsx,json}',
+    'fastapi': '**/*.{py,requirements.txt,Pipfile,pyproject.toml}',
+  };
+
+  if (GLOB_MAP[skillName]) {
+    return { globs: GLOB_MAP[skillName], alwaysApply: false };
   }
 
   return { globs: '', alwaysApply: false };
@@ -118,7 +112,10 @@ function generateCursorMdc(skillDir) {
   const body = stripFrontmatter(raw);
   const { globs, alwaysApply } = getSkillGlobsAndFlags(skillName);
 
-  const cleanDescription = description.replace(/\r?\n+/g, ' ').replace(/"/g, "'").trim();
+  let cleanDescription = description.replace(/\r?\n+/g, ' ').replace(/"/g, "'").trim();
+  if (!globs && !alwaysApply) {
+    cleanDescription = `Agent-requested: invoke when working on ${title}. ${cleanDescription}`.trim();
+  }
   const mdcContent = `---
 description: "${cleanDescription}"
 globs: ${globs ? `"${globs}"` : '""'}

package/.agents/core/profiles/mvp.yaml

@@ -25,6 +25,7 @@ prefer_skills:
 exclude_skills:
   - ddd
   - microservices
+  - system-design
   - kubernetes
   - monitoring
   - cicd

package/.agents/ctx.js

@@ -46,6 +46,10 @@ function printHelp() {
   console.log('  audit                           Alias for validate (check skills)');
   console.log('  validate                        Validate skill sources, frontmatter, deps & sync');
   console.log('  clean-worktrees                 Clean up lingering .swarm-worktrees and swarm/* branches');
+  console.log('  doctor                          Run project diagnostic health check');
+  console.log('  stats                           Display token context savings report');
+  console.log('  watch                           Start continuous file watcher and auto-sync daemon');
+  console.log('  init                            Show initialization guide');
   console.log('  install-skill <ref>             Alias for skill add (install a plugin)');
   console.log('  skill add   <ref>               Install a plugin skill (GitHub or npm)');
   console.log('  skill remove <name>             Uninstall a plugin skill');
@@ -301,7 +305,8 @@ if (command === 'export') {
   }
 
   if (subcommand === 'add') {
-    plugins.add(ref, { dryRun, checksum }).catch(err => {
+    const forceUnsafe = args.includes('--force-unsafe-prompts') || args.includes('--force-unsafe');
+    plugins.add(ref, { dryRun, checksum, forceUnsafe }).catch(err => {
       console.error(`[ERROR] ${err.message}`);
       process.exit(1);
     });
@@ -323,7 +328,7 @@ if (command === 'export') {
 
 // ── clean-worktrees ──────────────────────────────────────────────────────────
 } else if (command === 'clean-worktrees' || command === 'clean') {
-  const { execSync } = require('child_process');
+  const { execSync, execFileSync } = require('child_process');
   const fs = require('fs');
   const path = require('path');
   const rootDir = path.resolve(__dirname, '..');
@@ -331,16 +336,16 @@ if (command === 'export') {
   
   console.log('Cleaning up ContextOS swarm worktrees and branches...');
   try {
-    execSync('git worktree prune', { cwd: rootDir, stdio: 'pipe' });
+    execFileSync('git', ['worktree', 'prune'], { cwd: rootDir, stdio: 'pipe' });
   } catch {}
 
   let branchCount = 0;
   try {
-    const branches = execSync('git branch --list "swarm/*"', { cwd: rootDir, encoding: 'utf-8' });
+    const branches = execFileSync('git', ['branch', '--list', 'swarm/*'], { cwd: rootDir, encoding: 'utf-8' });
     const list = branches.split('\n').map(b => b.replace(/^[*+\s]+/, '').trim()).filter(Boolean);
     for (const b of list) {
       try {
-        execSync(`git branch -D "${b}"`, { cwd: rootDir, stdio: 'pipe' });
+        execFileSync('git', ['branch', '-D', b], { cwd: rootDir, stdio: 'pipe' });
         branchCount++;
       } catch {}
     }
@@ -362,6 +367,33 @@ if (command === 'export') {
 
   console.log(`✓ Cleaned up ${dirCount} worktree directory(ies) and ${branchCount} swarm branch(es).`);
 
+// ── doctor ────────────────────────────────────────────────────────────────────
+} else if (command === 'doctor') {
+  const doctorModule = require('./doctor.js');
+  doctorModule.runDoctor(process.cwd());
+
+// ── stats ─────────────────────────────────────────────────────────────────────
+} else if (command === 'stats') {
+  const statsModule = require('./stats.js');
+  statsModule.runStats(process.cwd());
+
+// ── watch ─────────────────────────────────────────────────────────────────────
+} else if (command === 'watch') {
+  const watchModule = require('./watch.js');
+  watchModule.runWatch(process.cwd());
+
+// ── init ──────────────────────────────────────────────────────────────────────
+} else if (command === 'init') {
+  console.log('\nContextOS — Project Initialization Guide\n');
+  console.log('To set up ContextOS in your project:');
+  console.log('  npx contextos                    Install .agents/ with auto-detected profile');
+  console.log('  npx contextos --minimal          Install with minimal core skills');
+  console.log('  npx contextos --profile <name>   Install with specific profile (mvp, startup, enterprise, etc.)');
+  console.log('  npx contextos --with-mcp         Install with MCP execution server enabled');
+  console.log('\nAfter setup, verify your installation:');
+  console.log('  node .agents/ctx.js doctor');
+  console.log('  node .agents/ctx.js stats\n');
+
 // ── unknown ───────────────────────────────────────────────────────────────────
 } else {
   console.error(`Unknown command: ${command}`);

package/.agents/doctor.js

@@ -0,0 +1,269 @@
+/**
+ * .agents/doctor.js
+ * ContextOS — Project Diagnostics & Health Check Engine
+ *
+ * Inspects:
+ *   1. .agents/ directory and core runtime files
+ *   2. Node.js environment compatibility
+ *   3. Active profile and skill exclusion/preference state
+ *   4. Compiled AI agent adapters (Gemini, Claude, Cursor, Copilot, etc.)
+ *   5. MCP server status and worktree support
+ *   6. Security controls (pre-commit hooks, secret scanning)
+ *   7. Project tech stack detection and recommended profile alignment
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const profiles = require('./profiles.js');
+
+const DOMAIN_MAP = {
+  frontend: new Set([
+    'react', 'react-best-practices', 'nextjs', 'typescript',
+    'ui-ux-pro', 'ui-design', 'ux-design', 'web-accessibility',
+    'brutalist-design', 'minimalist-design', 'soft-design', 'redesign-audit',
+    'impeccable-design', 'state-management',
+  ]),
+  backend: new Set([
+    'node', 'fastapi', 'nestjs', 'database', 'system-design',
+    'ddd', 'microservices',
+  ]),
+  cross: new Set([
+    'engineering-workflow', 'gstack-roles', 'ponytail-mindset',
+    'gemini-precision', 'interview-me', 'security', 'testing',
+    'performance', 'vercel-optimize', 'docker', 'decisions',
+    'architecture-diagrams', 'subagent-orchestrator', 'graphify',
+    'context-manager', 'context-os', 'adapters', 'generators',
+  ]),
+};
+
+function checkNodeVersion() {
+  const version = process.version; // e.g. v22.12.0
+  const match = version.match(/^v?(\d+)\.(\d+)/);
+  if (!match) return { ok: false, version, message: `${version} (unknown)` };
+
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  // Requires at least Node 18.0.0 or 16.7.0 for recursive cpSync
+  const ok = major > 16 || (major === 16 && minor >= 7);
+  return {
+    ok,
+    version,
+    message: ok ? `Node.js ${version} (>= 16.7.0 required)` : `Node.js ${version} (< 16.7.0, please upgrade)`,
+  };
+}
+
+function checkPreCommitHook(projectDir) {
+  const hookPath = path.join(projectDir, '.git', 'hooks', 'pre-commit');
+  if (!fs.existsSync(hookPath)) {
+    return { ok: false, message: 'not installed (run: npm run setup:hooks)' };
+  }
+  try {
+    const content = fs.readFileSync(hookPath, 'utf8');
+    if (content.includes('check-secrets')) {
+      return { ok: true, message: 'installed (with secret check)' };
+    }
+    return { ok: false, message: 'installed but missing check-secrets' };
+  } catch {
+    return { ok: false, message: 'unreadable' };
+  }
+}
+
+function checkSecretScanner(projectDir) {
+  const scriptPath = path.join(projectDir, 'scripts', 'check-secrets.js');
+  if (!fs.existsSync(scriptPath)) {
+    return { ok: true, message: 'scanner script not present (skipped)' };
+  }
+  try {
+    execFileSync(process.execPath, [scriptPath, '--all'], {
+      cwd: projectDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, message: '0 findings' };
+  } catch (err) {
+    return { ok: false, message: 'potential secrets detected (run: npm run check:secrets)' };
+  }
+}
+
+function checkCompiledAdapters(projectDir) {
+  const compiled = [];
+  const genGemini = path.join(projectDir, '.agents', 'generated', 'gemini', 'skills');
+  if (fs.existsSync(genGemini) && fs.readdirSync(genGemini).length > 0) {
+    compiled.push('gemini');
+  }
+  const genClaude = path.join(projectDir, '.agents', 'generated', 'claude', 'skills');
+  if (fs.existsSync(genClaude) && fs.readdirSync(genClaude).length > 0) {
+    compiled.push('claude');
+  }
+  if (fs.existsSync(path.join(projectDir, '.cursorrules')) || fs.existsSync(path.join(projectDir, '.cursor', 'rules'))) {
+    compiled.push('cursor');
+  }
+  if (fs.existsSync(path.join(projectDir, '.github', 'copilot-instructions.md'))) {
+    compiled.push('copilot');
+  }
+  if (fs.existsSync(path.join(projectDir, '.aider.conf.yml'))) {
+    compiled.push('aider');
+  }
+  if (fs.existsSync(path.join(projectDir, '.zed', 'rules.md'))) {
+    compiled.push('zed');
+  }
+  return compiled;
+}
+
+function inspectSkills(projectDir, activeProfile) {
+  const skillsDir = path.join(projectDir, '.agents', 'core', 'skills');
+  if (!fs.existsSync(skillsDir)) return { total: 0, active: 0, excluded: 0, byDomain: { frontend: [], backend: [], cross: [] } };
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  const allSkills = entries
+    .filter(e => e.isDirectory() && fs.existsSync(path.join(skillsDir, e.name, 'SKILL.md')))
+    .map(e => e.name);
+
+  const excludedSet = new Set(activeProfile ? activeProfile.exclude_skills || [] : []);
+  const activeSkills = allSkills.filter(s => !excludedSet.has(s));
+
+  const byDomain = { frontend: [], backend: [], cross: [] };
+  for (const s of activeSkills) {
+    if (DOMAIN_MAP.frontend.has(s)) byDomain.frontend.push(s);
+    else if (DOMAIN_MAP.backend.has(s)) byDomain.backend.push(s);
+    else byDomain.cross.push(s);
+  }
+
+  return {
+    total: allSkills.length,
+    active: activeSkills.length,
+    excluded: excludedSet.size,
+    byDomain,
+  };
+}
+
+function runDoctor(projectDir = process.cwd()) {
+  const version = (() => {
+    try {
+      return require('../package.json').version;
+    } catch {
+      return '1.5.0';
+    }
+  })();
+
+  const agentsDir = path.join(projectDir, '.agents');
+  const hasAgents = fs.existsSync(agentsDir);
+  const nodeCheck = checkNodeVersion();
+  const activeProfile = hasAgents ? profiles.getActiveProfile(projectDir) : null;
+  const skillsInfo = inspectSkills(projectDir, activeProfile);
+  const compiledAdapters = checkCompiledAdapters(projectDir);
+
+  const mcpServerPath = path.join(projectDir, '.agents', 'mcp', 'server.mjs');
+  const hasMcp = fs.existsSync(mcpServerPath);
+
+  const hookCheck = checkPreCommitHook(projectDir);
+  const secretCheck = checkSecretScanner(projectDir);
+  const stack = profiles.detectStack(projectDir);
+
+  console.log('\n┌─────────────────────────────────────────────────────────────┐');
+  console.log(`│  ContextOS Doctor — Project Health Check  v${version.padEnd(16)}│`);
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('│                                                             │');
+
+  // .agents directory
+  if (hasAgents) {
+    console.log('│  ✓ .agents/ directory found                                 │');
+  } else {
+    console.log('│  ✗ .agents/ directory missing (run: npx contextos-agents)    │');
+  }
+
+  // Node version
+  const nodeIcon = nodeCheck.ok ? '✓' : '✗';
+  console.log(`│  ${nodeIcon} ${nodeCheck.message.padEnd(58)}│`);
+
+  // Active profile
+  if (activeProfile) {
+    const profStr = `Active profile: ${activeProfile.name || activeProfile.profile}`;
+    console.log(`│  ✓ ${profStr.padEnd(58)}│`);
+  } else {
+    console.log('│  • Active profile: default (no profile locked)              │');
+  }
+
+  // Skills
+  const skillsStr = `Skills loaded: ${skillsInfo.active} / ${skillsInfo.total}` +
+    (skillsInfo.excluded > 0 ? ` (${skillsInfo.excluded} excluded by profile)` : '');
+  console.log(`│  ✓ ${skillsStr.padEnd(58)}│`);
+
+  // Adapters
+  if (compiledAdapters.length > 0) {
+    const adaptStr = `Adapters compiled: ${compiledAdapters.join(', ')}`;
+    console.log(`│  ✓ ${adaptStr.padEnd(58)}│`);
+  } else {
+    console.log('│  • Adapters compiled: none (run: contextos export gemini)   │');
+  }
+
+  // MCP
+  if (hasMcp) {
+    console.log('│  ✓ MCP server: installed (.agents/mcp/server.mjs)           │');
+  } else {
+    console.log('│  • MCP server: not installed (run: contextos setup-mcp)     │');
+  }
+
+  // Security
+  const hookIcon = hookCheck.ok ? '✓' : '•';
+  const hookStr = `Pre-commit hook: ${hookCheck.message}`;
+  console.log(`│  ${hookIcon} ${hookStr.padEnd(58)}│`);
+
+  const secretIcon = secretCheck.ok ? '✓' : '✗';
+  const secretStr = `Secret scanner: ${secretCheck.message}`;
+  console.log(`│  ${secretIcon} ${secretStr.padEnd(58)}│`);
+
+  console.log('│                                                             │');
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('│  Project Stack & Profile Recommendations                    │');
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('│                                                             │');
+
+  const detectedStr = `Detected Stack: ${stack.detected.length ? stack.detected.join(', ') : 'Generic JS'}`;
+  console.log(`│  • ${detectedStr.slice(0, 56).padEnd(56)} │`);
+
+  const recProfStr = `Recommended Profile: ${stack.recommendedProfile}`;
+  console.log(`│  • ${recProfStr.padEnd(56)} │`);
+
+  console.log('│                                                             │');
+  console.log('│  Skills by Domain:                                          │');
+
+  const feStr = `Frontend (${skillsInfo.byDomain.frontend.length}): ${skillsInfo.byDomain.frontend.slice(0, 4).join(', ')}${skillsInfo.byDomain.frontend.length > 4 ? '...' : ''}`;
+  console.log(`│    ${feStr.padEnd(57)}│`);
+
+  const beStr = `Backend  (${skillsInfo.byDomain.backend.length}): ${skillsInfo.byDomain.backend.slice(0, 4).join(', ')}${skillsInfo.byDomain.backend.length > 4 ? '...' : ''}`;
+  console.log(`│    ${beStr.padEnd(57)}│`);
+
+  const crStr = `Cross    (${skillsInfo.byDomain.cross.length}): ${skillsInfo.byDomain.cross.slice(0, 4).join(', ')}${skillsInfo.byDomain.cross.length > 4 ? '...' : ''}`;
+  console.log(`│    ${crStr.padEnd(57)}│`);
+
+  console.log('│                                                             │');
+  console.log('└─────────────────────────────────────────────────────────────┘\n');
+
+  return {
+    hasAgents,
+    nodeOk: nodeCheck.ok,
+    activeProfile,
+    skillsInfo,
+    compiledAdapters,
+    hasMcp,
+    hookCheck,
+    secretCheck,
+    stack,
+  };
+}
+
+if (require.main === module) {
+  runDoctor();
+}
+
+module.exports = {
+  runDoctor,
+  checkNodeVersion,
+  checkPreCommitHook,
+  checkSecretScanner,
+  checkCompiledAdapters,
+  inspectSkills,
+};

package/.agents/mcp/runtime.py

@@ -38,6 +38,8 @@ _FORBIDDEN_ATTRIBUTES = {
     '__globals__', '__code__', '__builtins__', '__import__',
     '__getattr__', '__setattr__', '__delattr__',
     '__reduce__', '__reduce_ex__',  # pickle-based escapes
+    'create_subprocess_shell', 'create_subprocess_exec',
+    'open_connection', 'start_server', 'connect_read_pipe', 'connect_write_pipe',
 }
 
 def _safe_import(name, globals=None, locals=None, fromlist=(), level=0):
@@ -340,6 +342,20 @@ def merge_threads() -> str:
         return raw
 
 
+class _SafeAsyncio:
+    gather = staticmethod(asyncio.gather)
+    sleep = staticmethod(asyncio.sleep)
+    wait = staticmethod(asyncio.wait)
+    Event = asyncio.Event
+    Queue = asyncio.Queue
+    Lock = asyncio.Lock
+    Semaphore = asyncio.Semaphore
+    TimeoutError = asyncio.TimeoutError
+    as_completed = staticmethod(asyncio.as_completed)
+
+_safe_asyncio = _SafeAsyncio()
+
+
 def _runtime_symbols() -> dict:
     """Return the dict of runtime symbols injected into the user namespace."""
     return {
@@ -352,7 +368,7 @@ def _runtime_symbols() -> dict:
         'merge_threads': merge_threads,
         'FINAL': FINAL,
         'FINAL_VAR': FINAL_VAR,
-        'asyncio': asyncio,
+        'asyncio': _safe_asyncio,
         'json': json,
     }