cli

var Commands = map[string]CommandDefinition{
	CmdAstName: {
		Name:        toolAstName,
		Description: "Print the AST of a function or file (shows detailed AST)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match function or file names",
				},
				"file": map[string]interface{}{
					"type":        "boolean",
					"description": "Print AST of file instead of function",
				},
			},
			Required: []string{"regex"},
		},

		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			fileFlag := false
			if file, ok := props["file"]; ok {
				fileFlag, ok = file.(bool)
				if !ok {
					return Command{}, fmt.Errorf("file must be a boolean")
				}
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{"file": fileFlag},
			}, nil
		},
		Function: cmdAst,
	},
	CmdBacktraceName: {
		Name:        toolBacktraceName,
		Description: "Run the backtrace analysis with parameters in config",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdBacktrace,
	},
	CmdBuildGraphName: {
		Name:        toolBuildGraphName,
		Description: "Build the inter-procedural dataflow graph",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdBuildGraph,
	},
	CmdCallersName: {
		Name:        toolCallersName,
		Description: "Show the callers of a function. Uses the best analysis loaded (e.g. pointer when loaded).",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match function names",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdCallers,
	},
	CmdCalleesName: {
		Name:        toolCalleesName,
		Description: "Show callees of a function. Uses the best analysis loaded (e.g. pointer when loaded).",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match function names",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdCallees,
	},
	CmdCdName: {
		Name:        toolCdName,
		Description: "Move to relative directory (system command)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"directory": map[string]interface{}{
					"type":        "string",
					"description": "Directory path to change to",
				},
			},
			Required: []string{"directory"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			directory, ok := props["directory"].(string)
			if !ok {
				return Command{}, fmt.Errorf("directory must be provided")
			}
			return Command{
				Args:  []string{directory},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdCd,
	},
	CmdExitName: {
		Name:        toolExitName,
		Description: "Exit the program (system command, terminates the server).",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdExit,
	},
	CmdFocusName: {
		Name:        toolFocusName,
		Description: "Focus on a specific function, so you can inspect ssa values, instructions, aliases...",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match function names",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdFocus,
	},
	CmdIntraName: {
		Name:        toolIntraName,
		Description: "Run intra-procedural dataflow analysis (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdIntra,
	},
	CmdListName: {
		Name: toolListName,
		Description: "List functions matching a regex (golang), " +
			"with options on listing reachable and summarized functions." +
			"Matches against the full function name (package name + opt. receiver + function name)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match full function names",
				},
				"reachable_only": map[string]interface{}{
					"type":        "boolean",
					"description": "List only reachable functions",
				},
				"summarized_only": map[string]interface{}{
					"type":        "boolean",
					"description": "List only summarized functions",
				},
			},
			Required: []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex := ""
			if regexObj, ok := props["regex"]; ok {
				if regexStr, ok := regexObj.(string); ok {
					regex = regexStr
				} else {
					return Command{}, fmt.Errorf("regex must be a string")
				}
			}
			flags := map[string]bool{}
			if reachableOnly, ok := props["reachable_only"]; ok {
				if reachableBool, ok := reachableOnly.(bool); ok {
					flags["r"] = reachableBool
				} else {
					return Command{}, fmt.Errorf("reachable_only must be a boolean")
				}
			}
			if summarizedOnly, ok := props["summarized_only"]; ok {
				if summarizedBool, ok := summarizedOnly.(bool); ok {
					flags["s"] = summarizedBool
				} else {
					return Command{}, fmt.Errorf("summarized_only must be a boolean")
				}
			}
			args := []string{}
			if regex != "" {
				args = []string{regex}
			}
			return Command{
				Args:  args,
				Flags: flags,
			}, nil
		},
		Function: cmdList,
	},
	CmdLoadName: {
		Name:        toolLoadName,
		Description: "Load new program from package paths. This resets the analysis state (pointer, dataflow, ..)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"paths": map[string]interface{}{
					"type":        "array",
					"items":       map[string]interface{}{"type": "string"},
					"description": "Paths to load (files or directory)",
				},
				"target": map[string]interface{}{
					"type":        "string",
					"description": "Target to load (state? shows available targets from config, required loaded config)",
				},
			},
			Required: []string{"paths"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			packagesObj, ok := props["paths"]
			if !ok {
				return Command{}, fmt.Errorf("paths must be provided")
			}
			packages, ok := packagesObj.([]interface{})
			if !ok {
				return Command{}, fmt.Errorf("paths must be an array")
			}
			args := make([]string, len(packages))
			for i, pkg := range packages {
				args[i], ok = pkg.(string)
				if !ok {
					return Command{}, fmt.Errorf("path must be a string")
				}
			}
			namedArgs := map[string]string{}
			if target, ok := props["target"]; ok {
				if targetStr, ok := target.(string); ok {
					namedArgs["target"] = targetStr
				} else {
					return Command{}, fmt.Errorf("target must be a string")
				}
			}
			return Command{
				Args:      args,
				Flags:     map[string]bool{},
				NamedArgs: namedArgs,
			}, nil
		},
		Function: cmdLoad,
	},
	CmdLoadPackagesName: {
		Name: toolLoadPackagesName,
		Description: "Load Go packages with optional type information for inspection." +
			" This is faster than loading a whole program, and doesn't require loading the main entry point." +
			"However, dataflow and pointer analyses will not be available.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"packages": map[string]interface{}{
					"type":        "array",
					"items":       map[string]interface{}{"type": "string"},
					"description": "Package paths to load",
				},
				"with_types": map[string]interface{}{
					"type":        "boolean",
					"description": "Load packages with types",
				},
			},
			Required: []string{"packages"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			packagesObj, ok := props["packages"]
			if !ok {
				return Command{}, fmt.Errorf("packages must be provided")
			}
			packages, ok := packagesObj.([]interface{})
			if !ok {
				return Command{}, fmt.Errorf("packages must be an array")
			}
			args := make([]string, len(packages))
			for i, pkg := range packages {
				args[i], ok = pkg.(string)
				if !ok {
					return Command{}, fmt.Errorf("package must be a string")
				}
			}
			flags := map[string]bool{}
			if withTypes, ok := props["with_types"]; ok {
				if withTypesBool, ok := withTypes.(bool); ok {
					flags["t"] = withTypesBool
				} else {
					return Command{}, fmt.Errorf("with_types must be a boolean")
				}
			}
			return Command{
				Args:  args,
				Flags: flags,
			}, nil
		},
		Function: cmdLoadPackages,
	},
	CmdLsName: {
		Name:        toolLsName,
		Description: "List files in directory (system command)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"path": map[string]interface{}{
					"type":        "string",
					"description": "Path to list (defaults to current directory)",
				},
			},
			Required: []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			path := "."
			if pathObj, ok := props["path"]; ok {
				if pathStr, ok := pathObj.(string); ok {
					path = pathStr
				} else {
					return Command{}, fmt.Errorf("path must be a string")
				}
			}
			return Command{
				Args:  []string{path},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdLs,
	},
	CmdMarkName: {
		Name:        toolMarkName,
		Description: "Show dataflow marks and associated instructions (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match names",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdMark,
	},
	CmdMayAliasName: {
		Name:        toolMayAliasName,
		Description: "Check if values may alias (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"values": map[string]interface{}{
					"type":        "string",
					"description": "Regex matching values to check for aliasing.",
				},
			},
			Required: []string{"values"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			if values, ok := props["values"].(string); ok {
				return Command{
					Args:  []string{values},
					Flags: map[string]bool{},
				}, nil
			}
			return Command{}, fmt.Errorf("values must be a string")
		},
		Function: cmdMayAlias,
	},
	CmdPackageName: {
		Name:        toolPackageName,
		Description: "Show package information of focused function (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match package names",
				},
			},
			Required: []string{},
		},

		Function: cmdPackage,
	},
	CmdRebuildName: {
		Name:        toolRebuildName,
		Description: "Rebuild the program being analyzed. Re-initializes the complex analyses!",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		Function: cmdRebuild,
	},
	CmdReconfigName: {
		Name:        toolReconfigName,
		Description: "Reload current config or load new configuration file. Re-initializes all the analyses.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"config_file": map[string]interface{}{
					"type":        "string",
					"description": "Path to config file",
				},
			},
			Required: []string{"config_file"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			configFile, ok := props["config_file"].(string)
			if !ok || configFile == "" {
				return Command{}, fmt.Errorf("config_file must be a non-empty string")
			}
			return Command{
				Args:  []string{configFile},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdReconfig,
	},
	CmdScanName: {
		Name:        toolScanName,
		Description: "Scan AST for identifiers and types matching regex patterns.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"pattern": map[string]interface{}{
					"type":        "string",
					"description": "Pattern to scan for",
				},
			},
			Required: []string{"pattern"},
		},
		Function: cmdScan,
	},
	CmdShowPackageName: {
		Name:        toolShowPackageName,
		Description: "Show detailed information about a loaded package including files and imports.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match package names",
				},
			},
			Required: []string{},
		},
		Function: cmdShowPackage,
	},
	CmdShowSsaName: {
		Name:        toolShowSsaName,
		Description: "Print the SSA representation of a function.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match full function names",
				},
			},
			Required: []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if ok && regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string if provided")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdShowSsa,
	},
	CmdShowEscapeName: {
		Name:        toolShowEscapeName,
		Description: "Print the escape graph of a function",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match full function names",
				},
			},
			Required: []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdShowEscape,
	},
	CmdMembersName: {
		Name:        toolMembersName,
		Description: "Print package members (functions, types, constants, globals) matching a regex",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match package names",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdMembers,
	},
	CmdRunDataflowName: {
		Name:        toolRunDataflowName,
		Description: "Run the dataflow analysis (advanced analysis)",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdRunDataflow,
	},
	CmdRunPointerName: {
		Name:        toolRunPointerName,
		Description: "Run the pointer analysis (advanced analysis, use to get callees)",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdRunPointer,
	},
	CmdShowDataflowName: {
		Name:        toolShowDataflowName,
		Description: "Build and print the inter-procedural dataflow graph (advanced analysis, run summarize first)",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdShowDataflow,
	},
	CmdSrcName: {
		Name:        toolSrcName,
		Description: "Print the source code of a function.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match full function names",
				},
			},
			Required: []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdSrc,
	},
	CmdSsaInstrName: {
		Name:        toolSsaInstrName,
		Description: "Show SSA instruction details (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"instruction": map[string]interface{}{
					"type":        "string",
					"description": "SSA instruction to examine",
				},
			},
			Required: []string{"instruction"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			instruction, ok := props["instruction"].(string)
			if !ok || instruction == "" {
				return Command{}, fmt.Errorf("instruction must be a non-empty string")
			}
			return Command{
				Args:  []string{instruction},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdSsaInstr,
	},
	CmdSsaValueName: {
		Name:        toolSsaValueName,
		Description: "Show SSA value details (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"value": map[string]interface{}{
					"type":        "string",
					"description": "SSA value to examine",
				},
			},
			Required: []string{"value"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			value, ok := props["value"].(string)
			if !ok || value == "" {
				return Command{}, fmt.Errorf("value must be a non-empty string")
			}
			return Command{
				Args:  []string{value},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdSsaValue,
	},
	CmdStateName: {
		Name:        toolStateName,
		Description: "Show current analysis state.",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdState,
	},
	CmdStatsName: {
		Name:        toolStatsName,
		Description: "Display comprehensive program statistics including SSA, defers, and closure usage.",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdStats,
	},
	CmdSummaryName: {
		Name: toolSummaryName,
		Description: "Print the internal dataflow summary of functions matching a regex. " +
			"You should have run summarize on that function first (or on all functions)." +
			"Running this may be very expensive!",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match full function names",
				},
				"filter": map[string]interface{}{
					"type":        "string",
					"description": "Filter for summary display",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			regex, ok := props["regex"].(string)
			if !ok || regex == "" {
				return Command{}, fmt.Errorf("regex must be a non-empty string")
			}
			namedArgs := map[string]string{}
			filter, ok := props["filter"].(string)
			if ok {
				namedArgs["f"] = filter
			}
			return Command{
				Args:      []string{regex, filter},
				Flags:     map[string]bool{},
				NamedArgs: namedArgs,
			}, nil
		},
		Function: cmdSummary,
	},
	CmdSummarizeName: {
		Name: toolSummarizeName,
		Description: "Build dataflow summaries for functions using intra-procedural analysis." +
			"Depending on internal parameters, running the tool without arguments may only instantiate " +
			"the summaries without building them.",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"regex": map[string]interface{}{
					"type":        "string",
					"description": "Regex to match full function names (optional)",
				},
				"force": map[string]interface{}{
					"type":        "boolean",
					"description": "Force summarization and bypass filters",
				},
			},
			Required: []string{"regex"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			forceFlag := false
			if force, ok := props["force"]; ok {
				if forceBool, ok := force.(bool); ok {
					forceFlag = forceBool
				} else {
					return Command{}, fmt.Errorf("force flag must be a boolean")
				}
			}
			regex := ""
			regexObj, ok := props["regex"]
			if !ok {

				return Command{}, fmt.Errorf("regex must be provided")
			}
			if ok {
				if regexStr, ok := regexObj.(string); ok {
					regex = regexStr
				} else {
					return Command{}, fmt.Errorf("regex must be a string")
				}
			}
			return Command{
				Args:  []string{regex},
				Flags: map[string]bool{"force": forceFlag},
			}, nil
		},
		Function: cmdSummarize,
	},
	CmdTaintName: {
		Name: toolTaintName,
		Description: "Run the taint analysis with parameters in config file. Does nothing if no config file has been" +
			"loaded, or the config file does not define any taint analysis problem.",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdTaint,
	},
	CmdTraceName: {
		Name:        toolTraceName,
		Description: "Trace dataflow paths for a specific SSA value through the program (advanced debugging analysis)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"target": map[string]interface{}{
					"type":        "string",
					"description": "Target to trace",
				},
			},
			Required: []string{"target"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			target, ok := props["target"].(string)
			if !ok || target == "" {
				return Command{}, fmt.Errorf("target must be a non-empty string")
			}
			return Command{
				Args:  []string{target},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdTrace,
	},
	CmdUnfocusName: {
		Name:        toolUnfocusName,
		Description: "Remove focus from current function (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type:       "object",
			Properties: map[string]interface{}{},
			Required:   []string{},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			return Command{
				Args:  []string{},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdUnfocus,
	},
	CmdWhereName: {
		Name:        toolWhereName,
		Description: "Show source file location of functions or current focused function (requires focused function)",
		InputSchema: tools.MCPInputSchema{
			Type: "object",
			Properties: map[string]interface{}{
				"target": map[string]interface{}{
					"type":        "string",
					"description": "Target to locate",
				},
			},
			Required: []string{"target"},
		},
		SchemaTranslation: func(props map[string]interface{}) (Command, error) {
			target, ok := props["target"].(string)
			if !ok || target == "" {
				return Command{}, fmt.Errorf("target must be a non-empty string")
			}
			return Command{
				Args:  []string{target},
				Flags: map[string]bool{},
			}, nil
		},
		Function: cmdWhere,
	},
}