v1

type AgentServiceClient interface {
	// Retrieve the complete devloop configuration for a project to understand
	// available rules, commands, file watch patterns, and project settings.
	//
	// Essential information provided:
	// - Available build/test rules (rules[].name)
	// - Commands executed by each rule (rules[].commands)
	// - File patterns that trigger each rule (rules[].watch patterns)
	// - Project settings like colors, logging, debouncing
	//
	// Usage Examples:
	// - Discover available rules: Parse rules[].name from response
	// - Find test commands: Look for rules with "test" in name or commands
	// - Understand file triggers: Examine rules[].watch.patterns
	//
	// Response Format: JSON string containing the complete .devloop.yaml content
	// with resolved settings and rule definitions.
	// mcp_tool_name:get_config
	GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error)
	// Get the current execution status and history of a specific rule.
	// Use this to monitor build/test progress and check for failures.
	//
	// Status Information Provided:
	// - Whether the rule is currently running
	// - When the current/last execution started
	// - Result of the last execution (SUCCESS, FAILED, RUNNING, IDLE)
	// - Execution history timestamps
	//
	// Common Use Cases:
	// - Check if a build is still running after triggering
	// - Verify if tests passed or failed
	// - Monitor long-running development servers
	// - Debug why a rule isn't executing
	//
	// Returns: Detailed status including timing and execution results
	// mcp_tool_name:get_rule_status
	GetRule(ctx context.Context, in *GetRuleRequest, opts ...grpc.CallOption) (*GetRuleResponse, error)
	// Manually execute a specific rule to run builds, tests, or other commands.
	// This bypasses file watching and immediately starts the rule's command sequence.
	//
	// Trigger Behavior:
	// - Terminates any currently running instance of the rule
	// - Executes all commands in the rule definition sequentially
	// - Updates rule status to RUNNING, then SUCCESS/FAILED based on results
	// - Generates log output that can be retrieved via streaming endpoints
	//
	// Common Use Cases:
	// - Run builds on demand ("trigger the backend build")
	// - Execute test suites ("run the test rule")
	// - Restart development servers ("trigger the dev-server rule")
	// - Force regeneration ("trigger the protobuf rule")
	//
	// Returns: Immediate response indicating if trigger was accepted
	// Use GetRule() to monitor actual execution progress
	// mcp_tool_name:trigger_rule
	TriggerRule(ctx context.Context, in *TriggerRuleRequest, opts ...grpc.CallOption) (*TriggerRuleResponse, error)
	// List all file glob patterns being monitored by a project for automatic rule triggering.
	// Use this to understand what files cause rebuilds and which rules will execute.
	//
	// Pattern Information:
	// - All include/exclude patterns from all rules combined
	// - Glob syntax: **/*.go, src/**/*.js, **/test_*.py, etc.
	// - Patterns are resolved relative to the project root
	//
	// Common Use Cases:
	// - Understand what file changes trigger builds
	// - Debug why edits aren't triggering rules
	// - Plan file organization to optimize build triggers
	// - Analyze project structure and dependencies
	//
	// Returns: Array of glob patterns currently being watched
	// mcp_tool_name:list_watched_paths
	ListWatchedPaths(ctx context.Context, in *ListWatchedPathsRequest, opts ...grpc.CallOption) (*ListWatchedPathsResponse, error)
	// Stream real-time logs for a specific rule in a project.
	// mcp_tool_name:stream_logs
	StreamLogs(ctx context.Context, in *StreamLogsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamLogsResponse], error)
}

type AgentServiceServer interface {
	// Retrieve the complete devloop configuration for a project to understand
	// available rules, commands, file watch patterns, and project settings.
	//
	// Essential information provided:
	// - Available build/test rules (rules[].name)
	// - Commands executed by each rule (rules[].commands)
	// - File patterns that trigger each rule (rules[].watch patterns)
	// - Project settings like colors, logging, debouncing
	//
	// Usage Examples:
	// - Discover available rules: Parse rules[].name from response
	// - Find test commands: Look for rules with "test" in name or commands
	// - Understand file triggers: Examine rules[].watch.patterns
	//
	// Response Format: JSON string containing the complete .devloop.yaml content
	// with resolved settings and rule definitions.
	// mcp_tool_name:get_config
	GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error)
	// Get the current execution status and history of a specific rule.
	// Use this to monitor build/test progress and check for failures.
	//
	// Status Information Provided:
	// - Whether the rule is currently running
	// - When the current/last execution started
	// - Result of the last execution (SUCCESS, FAILED, RUNNING, IDLE)
	// - Execution history timestamps
	//
	// Common Use Cases:
	// - Check if a build is still running after triggering
	// - Verify if tests passed or failed
	// - Monitor long-running development servers
	// - Debug why a rule isn't executing
	//
	// Returns: Detailed status including timing and execution results
	// mcp_tool_name:get_rule_status
	GetRule(context.Context, *GetRuleRequest) (*GetRuleResponse, error)
	// Manually execute a specific rule to run builds, tests, or other commands.
	// This bypasses file watching and immediately starts the rule's command sequence.
	//
	// Trigger Behavior:
	// - Terminates any currently running instance of the rule
	// - Executes all commands in the rule definition sequentially
	// - Updates rule status to RUNNING, then SUCCESS/FAILED based on results
	// - Generates log output that can be retrieved via streaming endpoints
	//
	// Common Use Cases:
	// - Run builds on demand ("trigger the backend build")
	// - Execute test suites ("run the test rule")
	// - Restart development servers ("trigger the dev-server rule")
	// - Force regeneration ("trigger the protobuf rule")
	//
	// Returns: Immediate response indicating if trigger was accepted
	// Use GetRule() to monitor actual execution progress
	// mcp_tool_name:trigger_rule
	TriggerRule(context.Context, *TriggerRuleRequest) (*TriggerRuleResponse, error)
	// List all file glob patterns being monitored by a project for automatic rule triggering.
	// Use this to understand what files cause rebuilds and which rules will execute.
	//
	// Pattern Information:
	// - All include/exclude patterns from all rules combined
	// - Glob syntax: **/*.go, src/**/*.js, **/test_*.py, etc.
	// - Patterns are resolved relative to the project root
	//
	// Common Use Cases:
	// - Understand what file changes trigger builds
	// - Debug why edits aren't triggering rules
	// - Plan file organization to optimize build triggers
	// - Analyze project structure and dependencies
	//
	// Returns: Array of glob patterns currently being watched
	// mcp_tool_name:list_watched_paths
	ListWatchedPaths(context.Context, *ListWatchedPathsRequest) (*ListWatchedPathsResponse, error)
	// Stream real-time logs for a specific rule in a project.
	// mcp_tool_name:stream_logs
	StreamLogs(*StreamLogsRequest, grpc.ServerStreamingServer[StreamLogsResponse]) error
}

type AgentService_StreamLogsClient = grpc.ServerStreamingClient[StreamLogsResponse]

type AgentService_StreamLogsServer = grpc.ServerStreamingServer[StreamLogsResponse]

type Config struct {
	ProjectId string    `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	Settings  *Settings `protobuf:"bytes,2,opt,name=settings,proto3" json:"settings,omitempty"`
	Rules     []*Rule   `protobuf:"bytes,3,rep,name=rules,proto3" json:"rules,omitempty"`
	// contains filtered or unexported fields
}

type CycleDetectionSettings struct {

	// Whether to enable cycle detection (default: true)
	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// Whether to perform static validation at startup (default: true)
	StaticValidation bool `protobuf:"varint,2,opt,name=static_validation,json=staticValidation,proto3" json:"static_validation,omitempty"`
	// Whether to enable dynamic rate limiting (default: false for now)
	DynamicProtection bool `protobuf:"varint,3,opt,name=dynamic_protection,json=dynamicProtection,proto3" json:"dynamic_protection,omitempty"`
	// Maximum triggers per minute before rate limiting kicks in (default: 10)
	MaxTriggersPerMinute uint32 `` /* 126-byte string literal not displayed */
	// Maximum chain depth for trigger relationships (default: 5)
	MaxChainDepth uint32 `protobuf:"varint,5,opt,name=max_chain_depth,json=maxChainDepth,proto3" json:"max_chain_depth,omitempty"`
	// Time window for file modification frequency detection in seconds (default: 60)
	FileThrashWindowSeconds uint32 `` /* 135-byte string literal not displayed */
	// Number of modifications within window to consider "thrashing" (default: 5)
	FileThrashThreshold uint32 `protobuf:"varint,7,opt,name=file_thrash_threshold,json=fileThrashThreshold,proto3" json:"file_thrash_threshold,omitempty"`
	// contains filtered or unexported fields
}

type GetConfigRequest struct {
	// contains filtered or unexported fields
}

type GetConfigResponse struct {

	// Complete project configuration as JSON string.
	// Contains: settings (logging, colors), rules (name, commands, watch patterns)
	// Parse this JSON to understand available rule names and their configurations.
	Config *Config `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	// contains filtered or unexported fields
}

type GetRuleRequest struct {

	// Required: The name of the rule to check status for.
	// Must match a rule name from GetConfig() response (rules[].name).
	// Examples: "backend", "frontend", "tests", "build"
	RuleName string `protobuf:"bytes,1,opt,name=rule_name,json=ruleName,proto3" json:"rule_name,omitempty"`
	// contains filtered or unexported fields
}

type GetRuleResponse struct {

	// Detailed status information including execution state, timing, and results.
	// Check rule_status.is_running to see if currently executing.
	// Check rule_status.last_build_status for SUCCESS/FAILED/IDLE state.
	Rule *Rule `protobuf:"bytes,1,opt,name=rule,proto3" json:"rule,omitempty"`
	// contains filtered or unexported fields
}

type ListWatchedPathsRequest struct {
	// contains filtered or unexported fields
}

type ListWatchedPathsResponse struct {

	// Array of glob patterns that trigger rule execution when matched files change.
	// Examples: "**/*.go", "src/**/*.js", "package.json", "**/test_*.py"
	Paths []string `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
	// contains filtered or unexported fields
}

type LogLine struct {

	// The project that generated this log line
	ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// The specific rule that produced this output (e.g., "backend", "frontend", "tests")
	RuleName string `protobuf:"bytes,2,opt,name=rule_name,json=ruleName,proto3" json:"rule_name,omitempty"`
	// The actual log content/output line from the command
	// This includes all stdout/stderr from the rule's commands
	Line string `protobuf:"bytes,3,opt,name=line,proto3" json:"line,omitempty"`
	// When this log line was generated (Unix timestamp in milliseconds)
	// Use this for time-based filtering and chronological ordering
	Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// contains filtered or unexported fields
}

type ProjectInfo struct {

	// Unique identifier for the project. This can be:
	// - Manually set in devloop.yaml settings.project_id (recommended for AI tools)
	// - Auto-generated from the project directory path (fallback)
	// Examples: "my-backend", "frontend-app", "user-service"
	ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// Absolute path to the project's root directory containing .devloop.yaml
	// This is where all relative paths in commands and file operations are resolved from.
	// Example: "/Users/dev/projects/my-app"
	ProjectRoot string `protobuf:"bytes,2,opt,name=project_root,json=projectRoot,proto3" json:"project_root,omitempty"`
	// contains filtered or unexported fields
}

type Rule struct {

	// The project this rule belongs to
	ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// The rule name (e.g., "backend", "frontend", "tests")
	// Must match a rule name from the project's .devloop.yaml configuration
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// The commands that will be executed for this rule
	Commands []string `protobuf:"bytes,3,rep,name=commands,proto3" json:"commands,omitempty"`
	// The rule matchers and the actions to take for them
	Watch []*RuleMatcher `protobuf:"bytes,4,rep,name=watch,proto3" json:"watch,omitempty"`
	// What to do when a file does not match any pattern by default
	DefaultAction string `protobuf:"bytes,5,opt,name=default_action,json=defaultAction,proto3" json:"default_action,omitempty"`
	// Prefix for this rule
	Prefix string `protobuf:"bytes,6,opt,name=prefix,proto3" json:"prefix,omitempty"`
	// The workdir for this rule.  If not specified then will default to the directory where the devloop config is in.
	WorkDir string `protobuf:"bytes,7,opt,name=work_dir,json=workDir,proto3" json:"work_dir,omitempty"`
	// Whether to skip running on init (default false = will run on init)
	// Set to true to prevent rule from executing when devloop starts up
	// Example: skip_run_on_init: true
	SkipRunOnInit bool `protobuf:"varint,8,opt,name=skip_run_on_init,json=skipRunOnInit,proto3" json:"skip_run_on_init,omitempty"`
	// Whether the rule will have verbose logs or not
	Verbose *bool `protobuf:"varint,9,opt,name=verbose,proto3,oneof" json:"verbose,omitempty"`
	// Delay for debouncing if rules matched multiple times in rapid successession
	DebounceDelay *uint64 `protobuf:"varint,10,opt,name=debounce_delay,json=debounceDelay,proto3,oneof" json:"debounce_delay,omitempty"`
	// Color to use to show the logs for this rule
	Color string            `protobuf:"bytes,11,opt,name=color,proto3" json:"color,omitempty"`
	Env   map[string]string `` /* 134-byte string literal not displayed */
	// Per-rule cycle protection override (if not set, inherits from global settings)
	// Set to false to disable cycle protection for this specific rule
	CycleProtection *bool `protobuf:"varint,13,opt,name=cycle_protection,json=cycleProtection,proto3,oneof" json:"cycle_protection,omitempty"`
	// Status of this rule
	Status *RuleStatus `protobuf:"bytes,14,opt,name=status,proto3" json:"status,omitempty"`
	// Whether to exit devloop when this rule fails startup (default: false)
	// Set to true to use legacy behavior where devloop exits on startup failure
	ExitOnFailedInit bool `protobuf:"varint,15,opt,name=exit_on_failed_init,json=exitOnFailedInit,proto3" json:"exit_on_failed_init,omitempty"`
	// Maximum number of retry attempts for failed startup (default: 10)
	MaxInitRetries uint32 `protobuf:"varint,16,opt,name=max_init_retries,json=maxInitRetries,proto3" json:"max_init_retries,omitempty"`
	// Base backoff duration in milliseconds for startup retries (default: 3000ms)
	// Grows exponentially: 3s, 6s, 12s, 24s, etc.
	InitRetryBackoffBase uint64 `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RuleMatcher struct {

	// Patterns to match this rule for
	Patterns []string `protobuf:"bytes,1,rep,name=patterns,proto3" json:"patterns,omitempty"`
	// Action to take when rule matches - currently "include" | "exclude"
	Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"`
	// contains filtered or unexported fields
}

type RuleStatus struct {
	ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	RuleName  string `protobuf:"bytes,2,opt,name=rule_name,json=ruleName,proto3" json:"rule_name,omitempty"`
	// Whether the rule is currently executing commands
	// true = commands are running, false = rule is idle
	IsRunning bool `protobuf:"varint,3,opt,name=is_running,json=isRunning,proto3" json:"is_running,omitempty"`
	// When the current execution started (Unix timestamp in milliseconds)
	// Only meaningful when is_running = true
	StartTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// When the last execution completed (Unix timestamp in milliseconds)
	// Use this to check how recently a rule was executed
	LastBuildTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=last_build_time,json=lastBuildTime,proto3" json:"last_build_time,omitempty"`
	// Result of the last execution. Possible values:
	// - "SUCCESS": All commands completed successfully (exit code 0)
	// - "FAILED": One or more commands failed (non-zero exit code)
	// - "RUNNING": Rule is currently executing
	// - "IDLE": Rule has not been executed yet
	LastBuildStatus string `protobuf:"bytes,6,opt,name=last_build_status,json=lastBuildStatus,proto3" json:"last_build_status,omitempty"`
	// contains filtered or unexported fields
}

type Settings struct {
	ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// Whether to prefix logs with rule name or not
	PrefixLogs bool `protobuf:"varint,2,opt,name=prefix_logs,json=prefixLogs,proto3" json:"prefix_logs,omitempty"`
	// Length of the prefix to format in if prefixing logs.
	PrefixMaxLength uint32 `protobuf:"varint,3,opt,name=prefix_max_length,json=prefixMaxLength,proto3" json:"prefix_max_length,omitempty"`
	// Default debounce delay for all rules if they do not have their own DB delay specified
	DefaultDebounceDelay *uint64 `` /* 130-byte string literal not displayed */
	// Whether to log verbosely or not
	Verbose            bool              `protobuf:"varint,5,opt,name=verbose,proto3" json:"verbose,omitempty"`
	ColorLogs          bool              `protobuf:"varint,6,opt,name=color_logs,json=colorLogs,proto3" json:"color_logs,omitempty"`
	ColorScheme        string            `protobuf:"bytes,7,opt,name=color_scheme,json=colorScheme,proto3" json:"color_scheme,omitempty"`
	CustomColors       map[string]string `` /* 171-byte string literal not displayed */
	DefaultWatchAction string            `protobuf:"bytes,9,opt,name=default_watch_action,json=defaultWatchAction,proto3" json:"default_watch_action,omitempty"`
	// Cycle detection configuration
	CycleDetection *CycleDetectionSettings `protobuf:"bytes,10,opt,name=cycle_detection,json=cycleDetection,proto3" json:"cycle_detection,omitempty"`
	// Whether to suppress colors from subprocess output (default: false)
	// When true, all subprocess output appears in plain text
	// When false, subprocess tools like npm, go test, etc. can output their native colors
	SuppressSubprocessColors bool `` /* 137-byte string literal not displayed */
	// Maximum number of rules that can run in parallel (default: 0 = unlimited)
	// Set to 1 for sequential execution, useful for debugging rule chains
	MaxParallelRules uint32 `protobuf:"varint,12,opt,name=max_parallel_rules,json=maxParallelRules,proto3" json:"max_parallel_rules,omitempty"`
	// contains filtered or unexported fields
}

type StreamLogsRequest struct {
	RuleName string `protobuf:"bytes,1,opt,name=rule_name,json=ruleName,proto3" json:"rule_name,omitempty"`
	Filter   string `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
	// Timeout (in seconds) if no new log lines found to be streamed
	// negative value  => Wait indefinitely/forever
	// 0 => use a default value (say 3s)
	Timeout int64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contains filtered or unexported fields
}

type StreamLogsResponse struct {
	Lines []*LogLine `protobuf:"bytes,1,rep,name=lines,proto3" json:"lines,omitempty"`
	// contains filtered or unexported fields
}

type TriggerRuleRequest struct {

	// Required: The name of the rule to execute.
	// Must match a rule name from GetConfig() response (rules[].name).
	// Examples: "backend", "frontend", "tests", "build"
	RuleName string `protobuf:"bytes,1,opt,name=rule_name,json=ruleName,proto3" json:"rule_name,omitempty"`
	// contains filtered or unexported fields
}

type TriggerRuleResponse struct {

	// Whether the trigger request was accepted and rule execution started.
	// true = rule is now running, false = trigger rejected
	Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	// Human-readable message explaining the result.
	// Use GetRule() to monitor actual execution progress.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedAgentServiceServer struct{}

type UnsafeAgentServiceServer interface {
	// contains filtered or unexported methods
}