@compilr-dev/sdk 0.10.6 → 0.10.8

package/dist/capabilities/auto-detect.d.ts

@@ -1,6 +1,8 @@
 /**
  * Auto-Detect Capabilities — scans agent messages for "Tool not found"
  * errors and auto-loads the corresponding capability packs.
+ * Also detects programming languages from file paths to pre-load
+ * language-specific analysis packs.
  */
 import type { Message } from '@compilr-dev/agents';
 import type { CapabilityManager } from './manager.js';

package/dist/capabilities/auto-detect.js

@@ -1,7 +1,23 @@
 /**
  * Auto-Detect Capabilities — scans agent messages for "Tool not found"
  * errors and auto-loads the corresponding capability packs.
+ * Also detects programming languages from file paths to pre-load
+ * language-specific analysis packs.
  */
+/**
+ * Map file extensions to language capability pack IDs.
+ */
+const EXT_TO_LANG_PACK = {
+    '.ts': 'lang_typescript',
+    '.tsx': 'lang_typescript',
+    '.js': 'lang_typescript',
+    '.jsx': 'lang_typescript',
+    '.mjs': 'lang_typescript',
+    '.cjs': 'lang_typescript',
+    '.py': 'lang_python',
+    '.pyw': 'lang_python',
+    '.go': 'lang_go',
+};
 /**
  * Scan recent messages for "Tool not found: X" errors and auto-load
  * the corresponding capability packs (max N per turn, loadable only).
@@ -45,5 +61,59 @@ export function autoDetectCapabilities(manager, messages, maxLoads = 2) {
         // Only scan the most recent user message
         break;
     }
+    // Also detect languages from file paths in recent tool calls
+    autoDetectLanguagePacks(manager, messages, result, maxLoads - result.loaded.length);
     return result;
 }
+/**
+ * Scan recent assistant messages for file-related tool calls (read_file, edit, write_file, glob)
+ * and auto-load language packs based on file extensions.
+ */
+function autoDetectLanguagePacks(manager, messages, result, maxLoads) {
+    if (maxLoads <= 0)
+        return;
+    const detectedPacks = new Set();
+    // Scan the last few assistant messages for tool_use blocks with file paths
+    const recentMessages = messages.slice(-6);
+    for (const msg of recentMessages) {
+        if (msg.role !== 'assistant' || typeof msg.content === 'string')
+            continue;
+        for (const block of msg.content) {
+            if (block.type !== 'tool_use')
+                continue;
+            // Extract file paths from common tool inputs
+            const input = block.input;
+            if (!input)
+                continue;
+            const paths = [];
+            if (typeof input.path === 'string')
+                paths.push(input.path);
+            if (typeof input.file_path === 'string')
+                paths.push(input.file_path);
+            if (typeof input.filePath === 'string')
+                paths.push(input.filePath);
+            if (typeof input.pattern === 'string')
+                paths.push(input.pattern);
+            for (const p of paths) {
+                const lastDot = p.lastIndexOf('.');
+                const ext = lastDot >= 0 ? p.slice(lastDot).toLowerCase() : '';
+                const packId = EXT_TO_LANG_PACK[ext];
+                if (packId && !manager.isLoaded(packId)) {
+                    detectedPacks.add(packId);
+                }
+            }
+        }
+    }
+    // Load detected language packs
+    let loaded = 0;
+    for (const packId of detectedPacks) {
+        if (loaded >= maxLoads)
+            break;
+        const tier = manager.getTier(packId);
+        if (tier === 'loadable') {
+            manager.load(packId, 'auto-detect');
+            result.loaded.push(packId);
+            loaded++;
+        }
+    }
+}

package/dist/capabilities/packs.js

@@ -327,6 +327,94 @@ export const CAPABILITY_PACKS = {
         estimatedPromptTokens: 60,
         estimatedToolTokens: 300,
     },
+    // ============= LANGUAGE-SPECIFIC ANALYSIS PACKS =============
+    lang_typescript: {
+        id: 'lang_typescript',
+        label: 'TypeScript/JavaScript Analysis',
+        tools: [
+            'ts_find_symbol',
+            'ts_find_references',
+            'ts_find_implementations',
+            'ts_find_dead_code',
+            'ts_find_duplicates',
+            'ts_find_patterns',
+            'ts_get_file_structure',
+            'ts_get_imports',
+            'ts_get_exports',
+            'ts_get_call_graph',
+            'ts_get_dependency_graph',
+            'ts_get_type_hierarchy',
+            'ts_get_complexity',
+            'ts_get_signature',
+            'ts_get_documentation',
+            'ts_read_function',
+            'ts_read_class',
+            'ts_read_type',
+        ],
+        readOnly: true,
+        promptModules: [],
+        promptSnippet: 'TypeScript/JS AST analysis loaded: ts_find_symbol, ts_get_call_graph, ts_get_type_hierarchy, ts_find_dead_code, ts_get_imports/exports, ts_find_patterns, ts_read_function/class/type. Use these for precise structural analysis (prefer over grep for code structure questions).',
+        estimatedPromptTokens: 120,
+        estimatedToolTokens: 4200,
+    },
+    lang_python: {
+        id: 'lang_python',
+        label: 'Python Analysis',
+        tools: [
+            'find_symbol_python',
+            'find_references_python',
+            'find_implementations_python',
+            'find_dead_code_python',
+            'find_duplicates_python',
+            'find_patterns_python',
+            'get_file_structure_python',
+            'get_imports_python',
+            'get_exports_python',
+            'get_call_graph_python',
+            'get_dependency_graph_python',
+            'get_class_hierarchy_python',
+            'get_complexity_python',
+            'get_signature_python',
+            'extract_docstrings_python',
+            'read_function_py',
+            'read_class_py',
+            'read_type_py',
+        ],
+        readOnly: true,
+        promptModules: [],
+        promptSnippet: 'Python AST analysis loaded: find_symbol_python, get_call_graph_python, get_class_hierarchy_python, find_dead_code_python, get_imports_python, extract_docstrings_python, read_function_py/class_py. Use these for precise structural analysis.',
+        estimatedPromptTokens: 120,
+        estimatedToolTokens: 4200,
+    },
+    lang_go: {
+        id: 'lang_go',
+        label: 'Go Analysis',
+        tools: [
+            'find_symbol_go',
+            'find_references_go',
+            'find_implementations_go',
+            'find_dead_code_go',
+            'find_duplicates_go',
+            'find_patterns_go',
+            'get_file_structure_go',
+            'get_imports_go',
+            'get_exports_go',
+            'get_call_graph_go',
+            'get_dependency_graph_go',
+            'get_class_hierarchy_go',
+            'get_complexity_go',
+            'get_signature_go',
+            'extract_docstrings_go',
+            'read_function_go',
+            'read_struct_go',
+            'read_type_go',
+        ],
+        readOnly: true,
+        promptModules: [],
+        promptSnippet: 'Go AST analysis loaded: find_symbol_go, get_call_graph_go, find_dead_code_go, get_imports_go, read_function_go/struct_go. Use these for precise structural analysis.',
+        estimatedPromptTokens: 120,
+        estimatedToolTokens: 4200,
+    },
 };
 /**
  * Mapping from forbidden pack IDs to suggested agent roles.

package/dist/index.d.ts

@@ -35,9 +35,9 @@
  */
 export { createCompilrAgent } from './agent.js';
 export type { CompilrAgentConfig, CompilrAgent, RunOptions, RunResult, ToolCallRecord, ToolConfig, UsageInfo, ProviderType, PermissionCallback, GuardrailConfig, ContextConfig, CapabilitiesConfig, } from './config.js';
-export { AgentTeam, TeamAgent, SharedContextManager, ArtifactStore, DelegationTracker, ContextResolver, } from './team/index.js';
+export { AgentTeam, TeamAgent, SharedContextManager, ArtifactStore, DelegationTracker, ContextResolver, createDelegationStatusTool, createHandoffTool, } from './team/index.js';
 export type { AgentTeamConfig, TeamAgentConfig, ITeamPersistence, IArtifactStorage, ISessionRegistry, CustomAgentDefinition, AgentTemplate, AgentWorkshopData, WorkshopRoleDef, WorkshopToolProfile, WorkshopModelTier, WorkshopSkillDef, PlanSubmitInfo, PlanSubmitResult, PlanModeExitInfo, PlanModeCallbacks, ToolConfig as TeamToolConfig, ToolTier, ToolGroup, ProfileInfo, } from './team/index.js';
-export type { AgentRole, RoleMetadata, ToolProfile, MascotExpression, BackgroundSessionInfo, SerializedTeam, SerializedTeamAgent, TeamMetadata, TeamEvent, TeamEventType, TeamEventHandler, Artifact, ArtifactType as TeamArtifactType, ArtifactSummary as TeamArtifactSummary, CreateArtifactOptions, UpdateArtifactOptions, SerializedArtifact, SharedContext, SharedProjectInfo, SharedTeamInfo, TeamRosterEntry, TeamActivity, TeamActivityType, SharedDecision, TokenBudget, SerializedSharedContext, ParsedMention, ParsedInput, ResolvedMention, ResolveOptions, ResolutionSource, Delegation, DelegationStatus, DelegationResult, CompletionEvent, CreateDelegationOptions, DelegationStats, DelegationTrackerEvents, SkillToolRequirement, } from './team/index.js';
+export type { AgentRole, RoleMetadata, ToolProfile, MascotExpression, BackgroundSessionInfo, SerializedTeam, SerializedTeamAgent, TeamMetadata, TeamEvent, TeamEventType, TeamEventHandler, Artifact, ArtifactType as TeamArtifactType, ArtifactSummary as TeamArtifactSummary, CreateArtifactOptions, UpdateArtifactOptions, SerializedArtifact, SharedContext, SharedProjectInfo, SharedTeamInfo, TeamRosterEntry, TeamActivity, TeamActivityType, SharedDecision, TokenBudget, SerializedSharedContext, ParsedMention, ParsedInput, ResolvedMention, ResolveOptions, ResolutionSource, Delegation, DelegationStatus, DelegationResult, CompletionEvent, CreateDelegationOptions, DelegationStats, DelegationTrackerEvents, HandoffResult, HandoffToolConfig, SkillToolRequirement, } from './team/index.js';
 export { ROLE_METADATA, ROLE_EXPERTISE, ROLE_GROUPS, PREDEFINED_ROLE_IDS, TOOL_GROUPS, TOOL_PROFILES, PROFILE_INFO, SKILL_REQUIREMENTS, CUSTOM_MASCOTS, buildAgentWorkshopData, buildSuggestedRolesMap, PLAN_MODE_BLOCKED_TOOLS, PLAN_MODE_DENIAL_MESSAGE, PLAN_MODE_PROMPT, isToolAllowedInPlanMode, getPlanModePrompt, } from './team/index.js';
 export { getToolsForProfile, detectProfileFromTools, isProfileReadOnly, generateToolAwarenessPrompt, generateCoordinatorGuidance, generateSpecialistGuidance, createDefaultToolConfig, validateToolConfig, getAllGroupIds, getGroupInfo, getGroupsByTier, getGroupsForProfile, assignMascot, generateCustomAgentSystemPrompt, getCustomAgentToolFilter, getCustomAgentProfileLabel, validateAgentId, isAgentIdTaken, createCustomAgentDefinition, listTemplates, getTemplate, saveTemplate, updateTemplate, deleteTemplate, createAgentFromTemplate, parseInputForMentions, getReferencedAgents, hasReferences, buildMessageWithContext, buildContextMap, findAgentForRole, findAgentById, getAvailableSpecialists, getSpecialistsSummary, hasSpecialists, suggestOwner, suggestOwners, matchesAgentExpertise, wouldCreateLoop, recordAssignment, getAssignmentHistory, clearAssignmentHistory, clearAllAssignmentHistory, canReassign, resolveAgentIdCollision, setActiveSharedContext, getActiveSharedContext, recordTeamActivity, getDefinedSkillNames, getSkillRequirements, checkSkillCompatibility, getCompatibleSkills, getAllRequiredTools, getSkillsByCategory, } from './team/index.js';
 export { codingPreset, readOnlyPreset, resolvePreset } from './presets/index.js';

package/dist/index.js

@@ -41,7 +41,7 @@ export { createCompilrAgent } from './agent.js';
 // Multi-Agent Team Orchestration
 // =============================================================================
 // Core classes
-export { AgentTeam, TeamAgent, SharedContextManager, ArtifactStore, DelegationTracker, ContextResolver, } from './team/index.js';
+export { AgentTeam, TeamAgent, SharedContextManager, ArtifactStore, DelegationTracker, ContextResolver, createDelegationStatusTool, createHandoffTool, } from './team/index.js';
 // Constants
 export { ROLE_METADATA, ROLE_EXPERTISE, ROLE_GROUPS, PREDEFINED_ROLE_IDS, TOOL_GROUPS, TOOL_PROFILES, PROFILE_INFO, SKILL_REQUIREMENTS, CUSTOM_MASCOTS, buildAgentWorkshopData, buildSuggestedRolesMap, 
 // Plan mode

package/dist/presets/coding.js

@@ -2,7 +2,7 @@
  * Coding preset — batteries-included for software development
  */
 import { readFileTool, writeFileTool, editTool, bashTool, bashOutputTool, killShellTool, grepTool, globTool, todoWriteTool, todoReadTool, webFetchTool, suggestTool, } from '@compilr-dev/agents';
-import { allCodingTools, unifiedTools } from '@compilr-dev/agents-coding';
+import { allCodingTools, unifiedTools, ts, python, go } from '@compilr-dev/agents-coding';
 const CODING_SYSTEM_PROMPT = `You are a skilled software engineer. You help users with coding tasks including:
 - Writing, reviewing, and debugging code
 - Understanding codebases and architecture
@@ -42,12 +42,23 @@ const utilityTools = [todoWriteTool, todoReadTool, suggestTool];
 /**
  * All coding preset tools combined
  */
+/**
+ * Language-specific AST analysis tools (loaded on-demand via capability packs).
+ * Registered in the MetaToolsRegistry but hidden until the matching
+ * lang_typescript / lang_python / lang_go pack is loaded.
+ */
+const langTools = [
+    ...ts.allTsTools,
+    ...python.allPythonTools,
+    ...go.allGoTools,
+];
 const allPresetTools = [
     ...fileTools,
     ...shellTools,
     ...utilityTools,
     ...allCodingTools,
     ...unifiedTools,
+    ...langTools,
 ];
 /**
  * Coding preset — full development environment

package/dist/team/delegation-tools.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Delegation & Handoff Tools — SDK Factories
+ *
+ * Factory functions for creating delegation_status and handoff tools.
+ * Both CLI and Desktop call these with platform-specific dependencies.
+ */
+import { type Tool } from '@compilr-dev/agents';
+import type { DelegationTracker } from './delegation-tracker.js';
+import type { AgentTeam } from './team.js';
+interface DelegationStatusInput {
+    delegation_id?: string;
+    agent_id?: string;
+    status?: 'active' | 'completed' | 'failed' | 'all';
+}
+/**
+ * Create a delegation_status tool that queries the given tracker.
+ * Read-only — safe for parallel execution.
+ */
+export declare function createDelegationStatusTool(tracker: DelegationTracker): Tool<DelegationStatusInput>;
+interface HandoffInput {
+    agentId: string;
+    task: string;
+    reason?: string;
+}
+/**
+ * Result from the platform's handoff handler.
+ */
+export interface HandoffResult {
+    /** Whether the handoff was executed */
+    success: boolean;
+    /** Whether the user declined the handoff */
+    declined?: boolean;
+    /** Error message (if any) */
+    error?: string;
+}
+/**
+ * Configuration for creating a handoff tool.
+ */
+export interface HandoffToolConfig {
+    /** The team instance for roster validation and one-hop tracking */
+    team: AgentTeam;
+    /** The current agent's ID (for one-hop rule enforcement) */
+    currentAgentId: string;
+    /**
+     * Platform-specific handoff handler. Called after validation.
+     * Should show approval UI if needed and execute the switch.
+     */
+    onHandoff: (targetAgentId: string, task: string, reason?: string) => Promise<HandoffResult>;
+}
+/**
+ * Create a handoff tool for a specific agent.
+ *
+ * The tool enforces the one-hop rule: if this agent was itself handed a task,
+ * it can only hand back to the coordinator (default agent), not to another specialist.
+ */
+export declare function createHandoffTool(config: HandoffToolConfig): Tool<HandoffInput>;
+export {};

package/dist/team/delegation-tools.js

@@ -0,0 +1,224 @@
+/**
+ * Delegation & Handoff Tools — SDK Factories
+ *
+ * Factory functions for creating delegation_status and handoff tools.
+ * Both CLI and Desktop call these with platform-specific dependencies.
+ */
+import { defineTool } from '@compilr-dev/agents';
+function formatDuration(from, to) {
+    const endTime = to ?? new Date();
+    const ms = endTime.getTime() - from.getTime();
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${String(hours)}h ${String(minutes % 60)}m`;
+    }
+    else if (minutes > 0) {
+        return `${String(minutes)}m ${String(seconds % 60)}s`;
+    }
+    else {
+        return `${String(seconds)}s`;
+    }
+}
+function formatDelegation(d) {
+    const entry = {
+        id: d.id,
+        targetAgent: d.targetAgentId,
+        task: d.task.length > 100 ? d.task.slice(0, 100) + '...' : d.task,
+        status: d.status,
+        duration: formatDuration(d.createdAt, d.completedAt),
+    };
+    if (d.todoIndex !== undefined) {
+        entry.todoIndex = d.todoIndex;
+    }
+    if (d.result) {
+        entry.result = {
+            success: d.result.success,
+            summary: d.result.summary,
+            artifactIds: d.result.artifactIds,
+            ...(d.result.error ? { error: d.result.error } : {}),
+        };
+    }
+    return entry;
+}
+/**
+ * Create a delegation_status tool that queries the given tracker.
+ * Read-only — safe for parallel execution.
+ */
+export function createDelegationStatusTool(tracker) {
+    return defineTool({
+        name: 'delegation_status',
+        description: 'Query the status of tasks delegated via delegate_background. ' +
+            'Returns active delegations by default (pending and running). ' +
+            'Use delegation_id for a specific delegation, agent_id to filter by agent, ' +
+            'or status to see completed/failed/all delegations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                delegation_id: {
+                    type: 'string',
+                    description: 'Specific delegation ID (e.g., "del_abc12345")',
+                },
+                agent_id: {
+                    type: 'string',
+                    description: 'Filter by target agent (e.g., "dev", "arch")',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['active', 'completed', 'failed', 'all'],
+                    description: 'Filter by status. Default: "active" (pending + running)',
+                },
+            },
+        },
+        execute: (input) => {
+            return Promise.resolve(executeDelegationStatus(tracker, input));
+        },
+    });
+}
+function executeDelegationStatus(tracker, input) {
+    // Single delegation lookup
+    if (input.delegation_id) {
+        const delegation = tracker.getDelegation(input.delegation_id);
+        if (!delegation) {
+            return {
+                success: false,
+                error: `Delegation ${input.delegation_id} not found`,
+            };
+        }
+        return {
+            success: true,
+            result: {
+                delegations: [formatDelegation(delegation)],
+                stats: tracker.getStats(),
+            },
+        };
+    }
+    // Get all delegations then filter
+    let delegations;
+    if (input.agent_id) {
+        delegations = tracker.getByAgent(input.agent_id);
+    }
+    else {
+        delegations = tracker.getAll();
+    }
+    // Apply status filter
+    const filter = input.status ?? 'active';
+    if (filter !== 'all') {
+        delegations = delegations.filter((d) => {
+            switch (filter) {
+                case 'active':
+                    return d.status === 'pending' || d.status === 'running';
+                case 'completed':
+                    return d.status === 'completed';
+                case 'failed':
+                    return d.status === 'failed';
+                default:
+                    return true;
+            }
+        });
+    }
+    return {
+        success: true,
+        result: {
+            delegations: delegations.map(formatDelegation),
+            stats: tracker.getStats(),
+        },
+    };
+}
+/**
+ * Create a handoff tool for a specific agent.
+ *
+ * The tool enforces the one-hop rule: if this agent was itself handed a task,
+ * it can only hand back to the coordinator (default agent), not to another specialist.
+ */
+export function createHandoffTool(config) {
+    const { team, currentAgentId, onHandoff } = config;
+    return defineTool({
+        name: 'handoff',
+        description: 'Hand off the current task to another team agent. ' +
+            'Use this when a task is outside your expertise or would benefit from another specialist. ' +
+            'The user will be asked to approve the handoff before switching. ' +
+            'Example: hand off architecture questions to $arch, implementation to $dev, testing to $qa.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: {
+                    type: 'string',
+                    description: 'Target agent ID (e.g., "arch", "dev", "qa", "default")',
+                },
+                task: {
+                    type: 'string',
+                    description: 'Task description for the target agent - be specific and clear',
+                },
+                reason: {
+                    type: 'string',
+                    description: 'Why this agent is better suited for the task (shown to user)',
+                },
+            },
+            required: ['agentId', 'task'],
+        },
+        execute: async (input) => {
+            // Validate input
+            if (!input.agentId || input.agentId.trim().length === 0) {
+                return { success: false, error: 'Agent ID is required' };
+            }
+            if (!input.task || input.task.trim().length === 0) {
+                return { success: false, error: 'Task description is required' };
+            }
+            const targetId = input.agentId.trim();
+            // Validate target agent exists in team
+            const allAgents = team.getAll();
+            const targetExists = allAgents.some((a) => a.id === targetId);
+            if (!targetExists) {
+                const available = allAgents.map((a) => a.id).join(', ');
+                return {
+                    success: false,
+                    error: `Agent "${targetId}" not found in team. Available: ${available}`,
+                };
+            }
+            // Enforce one-hop rule
+            if (team.wasHandedTo(currentAgentId) && targetId !== 'default') {
+                const source = team.getHandoffSource(currentAgentId);
+                return {
+                    success: false,
+                    error: `One-hop rule: you were handed this task by $${source ?? 'unknown'} ` +
+                        `and cannot re-hand it to another specialist. ` +
+                        `You can only hand back to $default (coordinator). ` +
+                        `Either complete the task yourself or hand back to the coordinator.`,
+                };
+            }
+            // Execute handoff via platform callback
+            try {
+                const result = await onHandoff(targetId, input.task.trim(), input.reason?.trim());
+                if (result.error) {
+                    return { success: false, error: result.error };
+                }
+                if (result.declined) {
+                    return {
+                        success: true,
+                        result: {
+                            handedOff: false,
+                            message: 'User declined the handoff. Continue handling the task yourself.',
+                        },
+                    };
+                }
+                // Record the handoff for one-hop tracking
+                team.recordHandoff(targetId, currentAgentId);
+                return {
+                    success: true,
+                    result: {
+                        handedOff: true,
+                        message: `Task handed off to $${targetId}. They will handle it from here.`,
+                    },
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `Handoff failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
+    });
+}

package/dist/team/index.d.ts

@@ -38,3 +38,5 @@ export { setActiveSharedContext, getActiveSharedContext, recordTeamActivity } fr
 export type { SkillToolRequirement } from './skill-requirements.js';
 export { SKILL_REQUIREMENTS, getDefinedSkillNames, getSkillRequirements, checkSkillCompatibility, getCompatibleSkills, getAllRequiredTools, getSkillsByCategory, } from './skill-requirements.js';
 export { resolveAgentIdCollision } from './collision-utils.js';
+export { createDelegationStatusTool, createHandoffTool } from './delegation-tools.js';
+export type { HandoffResult, HandoffToolConfig } from './delegation-tools.js';

package/dist/team/index.js

@@ -31,3 +31,5 @@ export { setActiveSharedContext, getActiveSharedContext, recordTeamActivity } fr
 export { SKILL_REQUIREMENTS, getDefinedSkillNames, getSkillRequirements, checkSkillCompatibility, getCompatibleSkills, getAllRequiredTools, getSkillsByCategory, } from './skill-requirements.js';
 // Collision utils
 export { resolveAgentIdCollision } from './collision-utils.js';
+// Delegation & Handoff tools (factory functions)
+export { createDelegationStatusTool, createHandoffTool } from './delegation-tools.js';

package/dist/team/tool-config.js

@@ -380,6 +380,85 @@ export const TOOL_GROUPS = {
         tier: 'meta',
         note: 'Generate project files from structured models',
     },
+    // Language-specific AST analysis (auto-loaded based on project language)
+    lang_typescript: {
+        label: 'TypeScript/JS Analysis',
+        tools: [
+            'ts_find_symbol',
+            'ts_find_references',
+            'ts_find_implementations',
+            'ts_find_dead_code',
+            'ts_find_duplicates',
+            'ts_find_patterns',
+            'ts_get_file_structure',
+            'ts_get_imports',
+            'ts_get_exports',
+            'ts_get_call_graph',
+            'ts_get_dependency_graph',
+            'ts_get_type_hierarchy',
+            'ts_get_complexity',
+            'ts_get_signature',
+            'ts_get_documentation',
+            'ts_read_function',
+            'ts_read_class',
+            'ts_read_type',
+        ],
+        readOnly: true,
+        tier: 'direct',
+        note: 'AST-based TypeScript/JavaScript analysis via TypeScript Compiler API',
+    },
+    lang_python: {
+        label: 'Python Analysis',
+        tools: [
+            'find_symbol_python',
+            'find_references_python',
+            'find_implementations_python',
+            'find_dead_code_python',
+            'find_duplicates_python',
+            'find_patterns_python',
+            'get_file_structure_python',
+            'get_imports_python',
+            'get_exports_python',
+            'get_call_graph_python',
+            'get_dependency_graph_python',
+            'get_class_hierarchy_python',
+            'get_complexity_python',
+            'get_signature_python',
+            'extract_docstrings_python',
+            'read_function_py',
+            'read_class_py',
+            'read_type_py',
+        ],
+        readOnly: true,
+        tier: 'direct',
+        note: 'AST-based Python analysis via Tree-sitter',
+    },
+    lang_go: {
+        label: 'Go Analysis',
+        tools: [
+            'find_symbol_go',
+            'find_references_go',
+            'find_implementations_go',
+            'find_dead_code_go',
+            'find_duplicates_go',
+            'find_patterns_go',
+            'get_file_structure_go',
+            'get_imports_go',
+            'get_exports_go',
+            'get_call_graph_go',
+            'get_dependency_graph_go',
+            'get_class_hierarchy_go',
+            'get_complexity_go',
+            'get_signature_go',
+            'extract_docstrings_go',
+            'read_function_go',
+            'read_struct_go',
+            'read_type_go',
+        ],
+        readOnly: true,
+        tier: 'direct',
+        note: 'AST-based Go analysis via Tree-sitter',
+    },
 };
 // =============================================================================
 // Tool Profiles
@@ -401,6 +480,9 @@ export const TOOL_PROFILES = {
         'search',
         'dependencies',
         'backlog_read',
+        'lang_typescript',
+        'lang_python',
+        'lang_go',
     ],
     // Developer - coding tasks
     developer: [
@@ -429,6 +511,9 @@ export const TOOL_PROFILES = {
         'web',
         'factory_models',
         'factory_scaffold',
+        'lang_typescript',
+        'lang_python',
+        'lang_go',
     ],
     // Security - security audits
     security: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/sdk",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "description": "Universal agent runtime for building AI-powered applications",
   "type": "module",
   "main": "dist/index.js",
@@ -76,7 +76,7 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
-    "@compilr-dev/agents-coding": "^1.0.6",
+    "@compilr-dev/agents-coding": "^1.0.8",
     "@eslint/js": "^9.39.1",
     "@opentelemetry/api": "^1.9.0",
     "@types/better-sqlite3": "^7.6.13",