brainclaw 0.19.14 → 0.21.0

package/dist/core/agent-capability.js

@@ -0,0 +1,196 @@
+/**
+ * Agent capability profiles — describes what integration surfaces each
+ * agent supports so brainclaw can adapt its instruction file content,
+ * integration depth, and pressure level accordingly.
+ *
+ * Three profile tiers drive instruction file templates:
+ *   A (full)    — MCP + hooks + auto-approve → lightweight instructions
+ *   B (standard) — MCP, no hooks → directive instructions with top traps
+ *   C (limited) — no MCP → rich static content (plans, traps, decisions)
+ */
+const PROFILES = {
+    'claude-code': {
+        name: 'claude-code',
+        hasMcp: true,
+        hasHooks: true,
+        hasAutoApprove: true,
+        hasSkills: true,
+        hasRules: true,
+        instructionFile: 'CLAUDE.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'both',
+        templateTier: 'A',
+    },
+    cursor: {
+        name: 'cursor',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.cursor/rules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    windsurf: {
+        name: 'windsurf',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.windsurfrules',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    cline: {
+        name: 'cline',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: true,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.clinerules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'project',
+        templateTier: 'B',
+    },
+    roo: {
+        name: 'roo',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: true,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.roo/rules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'project',
+        templateTier: 'B',
+    },
+    continue: {
+        name: 'continue',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.continue/rules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'both',
+        templateTier: 'B',
+    },
+    opencode: {
+        name: 'opencode',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: 'AGENTS.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'project',
+        templateTier: 'B',
+    },
+    codex: {
+        name: 'codex',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: 'AGENTS.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    antigravity: {
+        name: 'antigravity',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: 'GEMINI.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    'github-copilot': {
+        name: 'github-copilot',
+        hasMcp: false,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: true,
+        hasRules: true,
+        instructionFile: '.github/copilot-instructions.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'none',
+        templateTier: 'C',
+    },
+    openclaw: {
+        name: 'openclaw',
+        hasMcp: false,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: true,
+        hasRules: false,
+        instructionFile: 'skills/openclaw/SKILL.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'none',
+        templateTier: 'C',
+    },
+};
+/**
+ * Get the capability profile for a known agent.
+ * Returns undefined for unknown agent names.
+ */
+export function getAgentCapabilityProfile(name) {
+    return PROFILES[name];
+}
+/**
+ * Get all known agent capability profiles.
+ */
+export function getAllAgentCapabilityProfiles() {
+    return Object.values(PROFILES);
+}
+/**
+ * Get all agent names that match a given template tier.
+ */
+export function getAgentsByTier(tier) {
+    return Object.values(PROFILES).filter((p) => p.templateTier === tier);
+}
+/**
+ * Check if an agent name is a known brainclaw-supported agent.
+ */
+export function isKnownAgent(name) {
+    return name in PROFILES;
+}
+/**
+ * Summarize which integration surfaces are available for a given agent.
+ * Useful for setup UI to explain what brainclaw will configure.
+ */
+export function describeAgentSurfaces(name) {
+    const profile = getAgentCapabilityProfile(name);
+    if (!profile)
+        return [];
+    const surfaces = [];
+    if (profile.hasMcp) {
+        surfaces.push(`MCP server (${profile.mcpConfigScope})`);
+    }
+    if (profile.hasRules) {
+        surfaces.push(`Instruction file (${profile.instructionFile})`);
+    }
+    if (profile.hasAutoApprove) {
+        surfaces.push('Auto-approve MCP tools');
+    }
+    if (profile.hasHooks) {
+        surfaces.push('Session hooks (pre-prompt + stop)');
+    }
+    if (profile.hasSkills) {
+        surfaces.push('Slash command / skill');
+    }
+    return surfaces;
+}
+//# sourceMappingURL=agent-capability.js.map

package/dist/core/agent-context.js

@@ -60,12 +60,30 @@ function readAgentsMarkdown(cwd) {
     const raw = fs.readFileSync(filepath, 'utf-8');
     const lines = raw.split(/\r?\n/);
     const title = lines.find((line) => line.trim().startsWith('#'))?.replace(/^#+\s*/, '').trim();
-    const rules = lines
-        .map((line) => line.trim())
-        .filter((line) => /^([-*]|\d+\.)\s+/.test(line))
-        .map((line) => line.replace(/^([-*]|\d+\.)\s+/, '').trim())
-        .filter(Boolean)
-        .slice(0, MAX_AGENT_RULES);
+    // Only extract rules from actionable sections, not from descriptive sections
+    // like "why this matters" which contain explanatory bullets, not instructions.
+    const SKIP_SECTIONS = /why this matters|what it provides|what brainclaw/i;
+    let currentSection = '';
+    let skipSection = false;
+    const rules = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#')) {
+            currentSection = trimmed.replace(/^#+\s*/, '');
+            skipSection = SKIP_SECTIONS.test(currentSection);
+            continue;
+        }
+        if (skipSection)
+            continue;
+        if (/^([-*]|\d+\.)\s+/.test(trimmed)) {
+            const text = trimmed.replace(/^([-*]|\d+\.)\s+/, '').trim();
+            if (text) {
+                rules.push(text);
+                if (rules.length >= MAX_AGENT_RULES)
+                    break;
+            }
+        }
+    }
     return {
         present: true,
         title,

package/dist/core/agent-integrations.js

@@ -57,6 +57,9 @@ const DEFAULT_SURFACES = {
         { kind: 'instructions', location: 'workspace', path: '.roo/rules/brainclaw.md' },
         { kind: 'mcp', location: 'workspace', path: '.roo/mcp.json' },
     ],
+    'openclaw': [
+        { kind: 'skill', location: 'machine', path: '.openclaw/workspace/skills/brainclaw/SKILL.md' },
+    ],
 };
 function mergeSurfaces(current, next) {
     const merged = [...current];

package/dist/core/ai-agent-detection.js

@@ -6,18 +6,20 @@ import os from 'node:os';
  * environment variables and well-known config paths. Returns the first confident
  * match, or undefined if no agent is detected.
  *
- * Detection order (highest confidence first):
+ * Detection order (highest confidence first — agents with dedicated env vars
+ * are tested before agents detected via passive/ambient env vars):
  * 1. BRAINCLAW_AGENT env var (explicit override)
- * 2. GitHub Copilot (VSCODE_GIT_IPC_HANDLE or VSCODE_INJECTION, then GITHUB_COPILOT_*)
- * 3. Claude Code (CLAUDE_CODE_VERSION or ANTHROPIC_AI_PRODUCT)
- * 4. Cursor (CURSOR_TRACE_ID or CURSOR_*)
- * 5. Windsurf (WINDSURF_*)
- * 6. Cline (CLINE_*)
+ * 2. Claude Code (CLAUDE_CODE_VERSION — set by Claude Code itself)
+ * 3. Cursor (CURSOR_TRACE_ID — set by Cursor itself)
+ * 4. Windsurf (WINDSURF_SESSION_ID — set by Windsurf itself)
+ * 5. Cline (CLINE_AGENT — set by Cline itself)
+ * 6. GitHub Copilot (GITHUB_COPILOT_PRODUCT — passive VS Code env, tested after active agents)
  * 7. Codex CLI (~/.codex/ directory exists)
  * 8. OpenCode (OPENCODE_* env or ~/.config/opencode/)
  * 9. Antigravity / Gemini CLI (ANTIGRAVITY_* env or ~/.gemini/antigravity/)
  * 10. Continue (CONTINUE_*)
  * 11. Roo Code (ROO_*)
+ * 12. OpenClaw (~/.openclaw/ or OPENCLAW_*)
  */
 export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
     // Explicit override
@@ -29,24 +31,14 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: 'BRAINCLAW_AGENT env var',
         };
     }
-    // GitHub Copilot — VS Code extension or Copilot Chat
-    if (env.GITHUB_COPILOT_TOKEN ||
-        env.GITHUB_COPILOT_PRODUCT ||
-        (env.VSCODE_GIT_IPC_HANDLE && (env.AGENT_NAME?.toLowerCase().includes('copilot') || env.GH_COPILOT_AGENT))) {
-        return {
-            name: 'github-copilot',
-            kind: 'agent',
-            trust_level: 'trusted',
-            detection_source: 'GITHUB_COPILOT_* env var',
-        };
-    }
-    // Claude Code (Anthropic's CLI coding agent)
+    // Claude Code — tested BEFORE Copilot because both can be present in VS Code.
+    // CLAUDE_CODE_VERSION is set by Claude Code itself, not by VS Code passively.
     if (env.CLAUDE_CODE_VERSION || env.ANTHROPIC_AI_PRODUCT === 'claude-code') {
         return {
             name: 'claude-code',
             kind: 'agent',
             trust_level: 'trusted',
-            detection_source: 'CLAUDE_CODE_VERSION env var',
+            detection_source: env.CLAUDE_CODE_VERSION ? 'CLAUDE_CODE_VERSION env var' : 'ANTHROPIC_AI_PRODUCT env var',
         };
     }
     // Cursor IDE
@@ -76,6 +68,20 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: 'CLINE_* env var',
         };
     }
+    // GitHub Copilot — tested AFTER agents with dedicated env vars.
+    // GITHUB_COPILOT_TOKEN and GITHUB_COPILOT_PRODUCT are set passively by VS Code
+    // whenever the Copilot extension is installed, even when another agent is active.
+    // We only match if no higher-priority agent was detected above.
+    if (env.GITHUB_COPILOT_PRODUCT ||
+        (env.GITHUB_COPILOT_TOKEN && !env.CLAUDE_CODE_VERSION && !env.CURSOR_TRACE_ID && !env.WINDSURF_SESSION_ID) ||
+        (env.VSCODE_GIT_IPC_HANDLE && (env.AGENT_NAME?.toLowerCase().includes('copilot') || env.GH_COPILOT_AGENT))) {
+        return {
+            name: 'github-copilot',
+            kind: 'agent',
+            trust_level: 'trusted',
+            detection_source: env.GITHUB_COPILOT_PRODUCT ? 'GITHUB_COPILOT_PRODUCT env var' : 'GITHUB_COPILOT_TOKEN env var',
+        };
+    }
     // OpenAI Codex CLI (~/.codex/ presence)
     if (fs.existsSync(path.join(homeDir, '.codex'))) {
         return {
@@ -121,6 +127,15 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: 'ROO_* env var',
         };
     }
+    // OpenClaw (~/.openclaw/ presence or OPENCLAW_* env)
+    if (env.OPENCLAW_SESSION_ID || env.OPENCLAW_AGENT || fs.existsSync(path.join(homeDir, '.openclaw'))) {
+        return {
+            name: 'openclaw',
+            kind: 'agent',
+            trust_level: 'trusted',
+            detection_source: env.OPENCLAW_SESSION_ID || env.OPENCLAW_AGENT ? 'OPENCLAW_* env var' : '~/.openclaw directory',
+        };
+    }
     return undefined;
 }
 /**

package/dist/core/bootstrap.js

@@ -267,6 +267,12 @@ function buildBootstrapArtifacts(input) {
     const repoAnalysis = analyzeRepository(input.cwd);
     sourcesScanned.push('repo-analysis');
     seeds.push(...extractRepoAnalysisSeeds(repoAnalysis, input.target));
+    // Additional brownfield sources (step 12)
+    const additionalSeeds = extractAdditionalBrownfieldSeeds(input.cwd, input.target);
+    if (additionalSeeds.seeds.length > 0) {
+        sourcesScanned.push(...additionalSeeds.sources);
+        seeds.push(...additionalSeeds.seeds);
+    }
     const gitProbe = probeGit(input.cwd, input.target);
     if (gitProbe.available) {
         sourcesScanned.push('git');
@@ -703,6 +709,44 @@ function probeGit(cwd, target) {
             }));
         }
     }
+    // Step 13: Active branches
+    const branchResult = spawnSync('git', ['branch', '--no-merged', 'HEAD', '--format=%(refname:short)'], {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 5000,
+    });
+    if (branchResult.status === 0) {
+        const branches = branchResult.stdout.split(/\r?\n/).map((b) => b.trim()).filter(Boolean).slice(0, 5);
+        for (const branch of branches) {
+            hotspotSeeds.push(createSeed({
+                text: `Active branch: ${branch}`,
+                seedKind: 'hotspot',
+                sourceKind: 'git',
+                sourceRef: `branch:${branch}`,
+                confidence: 'low',
+                tags: ['bootstrap', 'git', 'branch'],
+            }));
+        }
+    }
+    // Step 13: Recent tags
+    const tagResult = spawnSync('git', ['tag', '--sort=-creatordate', '-l'], {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 5000,
+    });
+    if (tagResult.status === 0) {
+        const tags = tagResult.stdout.split(/\r?\n/).map((t) => t.trim()).filter(Boolean).slice(0, 3);
+        if (tags.length > 0) {
+            hotspotSeeds.push(createSeed({
+                text: `Version tags: ${tags.join(', ')} (${tags.length} most recent)`,
+                seedKind: 'convention',
+                sourceKind: 'git',
+                sourceRef: 'tags',
+                confidence: 'medium',
+                tags: ['bootstrap', 'git', 'versioning'],
+            }));
+        }
+    }
     return {
         available: true,
         repoFingerprint,
@@ -1594,4 +1638,137 @@ function normalizeTarget(target) {
     const trimmed = target?.trim();
     return trimmed && trimmed.length > 0 ? trimmed : undefined;
 }
+// ─── Step 12: Additional brownfield sources ──────────────────────────────────
+const CI_WORKFLOW_DIRS = ['.github/workflows', '.gitlab'];
+const CI_FILES = ['.gitlab-ci.yml', 'Jenkinsfile', '.circleci/config.yml'];
+const CONTRIBUTING_FILES = ['CONTRIBUTING.md', 'CONTRIBUTING'];
+const CHANGELOG_FILES = ['CHANGELOG.md', 'CHANGELOG', 'HISTORY.md'];
+const DOCKER_FILES = ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
+const ENV_EXAMPLE_FILES = ['.env.example', '.env.sample', '.env.template'];
+const ADR_DIRS = ['doc/adr', 'docs/adr', 'doc/decisions', 'docs/decisions', 'adr'];
+function extractAdditionalBrownfieldSeeds(cwd, target) {
+    const seeds = [];
+    const sources = [];
+    // CI/CD workflows
+    for (const dir of CI_WORKFLOW_DIRS) {
+        const fullPath = path.join(cwd, dir);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+            sources.push('ci_workflows');
+            try {
+                const files = fs.readdirSync(fullPath).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+                if (files.length > 0) {
+                    seeds.push(createSeed({
+                        text: `CI/CD: ${files.length} workflow(s) in ${dir}/`,
+                        seedKind: 'convention',
+                        sourceKind: 'ci_config',
+                        sourceRef: dir,
+                        confidence: 'medium',
+                        tags: ['bootstrap', 'ci'],
+                        relatedPaths: target ? [target] : undefined,
+                    }));
+                }
+            }
+            catch { /* skip unreadable */ }
+            break;
+        }
+    }
+    for (const file of CI_FILES) {
+        if (fs.existsSync(path.join(cwd, file))) {
+            if (!sources.includes('ci_workflows'))
+                sources.push('ci_config');
+            seeds.push(createSeed({
+                text: `CI/CD config: ${file}`,
+                seedKind: 'convention',
+                sourceKind: 'ci_config',
+                sourceRef: file,
+                confidence: 'medium',
+                tags: ['bootstrap', 'ci'],
+            }));
+            break;
+        }
+    }
+    // CONTRIBUTING.md
+    const contributingPath = findFirstExisting(cwd, CONTRIBUTING_FILES);
+    if (contributingPath) {
+        sources.push('contributing');
+        seeds.push(createSeed({
+            text: `Contributing guide found: ${path.basename(contributingPath)}`,
+            seedKind: 'convention',
+            sourceKind: 'contributing',
+            sourceRef: path.basename(contributingPath),
+            confidence: 'medium',
+            tags: ['bootstrap', 'contributing'],
+        }));
+    }
+    // CHANGELOG
+    const changelogPath = findFirstExisting(cwd, CHANGELOG_FILES);
+    if (changelogPath) {
+        sources.push('changelog');
+        seeds.push(createSeed({
+            text: `Changelog found: ${path.basename(changelogPath)}`,
+            seedKind: 'convention',
+            sourceKind: 'changelog',
+            sourceRef: path.basename(changelogPath),
+            confidence: 'low',
+            tags: ['bootstrap', 'changelog'],
+        }));
+    }
+    // Docker
+    for (const file of DOCKER_FILES) {
+        if (fs.existsSync(path.join(cwd, file))) {
+            sources.push('docker');
+            seeds.push(createSeed({
+                text: `Docker config: ${file}`,
+                seedKind: 'convention',
+                sourceKind: 'docker',
+                sourceRef: file,
+                confidence: 'medium',
+                tags: ['bootstrap', 'docker', 'infrastructure'],
+            }));
+            break;
+        }
+    }
+    // .env.example
+    const envPath = findFirstExisting(cwd, ENV_EXAMPLE_FILES);
+    if (envPath) {
+        sources.push('env_example');
+        try {
+            const content = fs.readFileSync(envPath, 'utf-8');
+            const varCount = content.split(/\r?\n/).filter((l) => l.includes('=') && !l.startsWith('#')).length;
+            seeds.push(createSeed({
+                text: `Environment template: ${path.basename(envPath)} (${varCount} variables)`,
+                seedKind: 'convention',
+                sourceKind: 'env_example',
+                sourceRef: path.basename(envPath),
+                confidence: 'medium',
+                tags: ['bootstrap', 'env', 'configuration'],
+            }));
+        }
+        catch { /* skip unreadable */ }
+    }
+    // ADR (Architecture Decision Records)
+    for (const dir of ADR_DIRS) {
+        const fullPath = path.join(cwd, dir);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+            sources.push('adr');
+            try {
+                const files = fs.readdirSync(fullPath).filter((f) => f.endsWith('.md'));
+                if (files.length > 0) {
+                    seeds.push(createSeed({
+                        text: `Architecture Decision Records: ${files.length} ADR(s) in ${dir}/`,
+                        seedKind: 'convention',
+                        sourceKind: 'adr',
+                        sourceRef: dir,
+                        confidence: 'high',
+                        tags: ['bootstrap', 'adr', 'architecture'],
+                        relatedPaths: target ? [target] : undefined,
+                    }));
+                }
+            }
+            catch { /* skip unreadable */ }
+            break;
+        }
+    }
+    return { seeds, sources: [...new Set(sources)] };
+}
 //# sourceMappingURL=bootstrap.js.map