coraline 0.8.0

Coraline: semantic code knowledge graph for faster AI-assisted development.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

#![forbid(unsafe_code)]

//! Context building tools for creating code context for tasks

use std::path::PathBuf;

use serde_json::{Value, json};

use crate::context;
use crate::types::{BuildContextOptions, ContextFormat};

use super::{Tool, ToolError, ToolResult};

/// Tool for building context for a task or query
pub struct BuildContextTool {
    project_root: PathBuf,
}

impl BuildContextTool {
    pub const fn new(project_root: PathBuf) -> Self {
        Self { project_root }
    }
}

impl Tool for BuildContextTool {
    fn name(&self) -> &'static str {
        "coraline_context"
    }

    fn description(&self) -> &'static str {
        "Build relevant code context for a task or issue description. Returns structured context with relevant symbols, code blocks, and file references."
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "task": {
                    "type": "string",
                    "description": "Task or issue description to build context for"
                },
                "max_nodes": {
                    "type": "number",
                    "description": "Maximum number of relevant nodes to include",
                    "default": 20
                },
                "max_code_blocks": {
                    "type": "number",
                    "description": "Maximum number of code blocks to include",
                    "default": 5
                },
                "max_code_block_size": {
                    "type": "number",
                    "description": "Maximum size of each code block in characters",
                    "default": 1500
                },
                "include_code": {
                    "type": "boolean",
                    "description": "Whether to include actual code blocks",
                    "default": true
                },
                "traversal_depth": {
                    "type": "number",
                    "description": "Depth for graph traversal from entry points",
                    "default": 1
                },
                "format": {
                    "type": "string",
                    "description": "Output format",
                    "enum": ["markdown", "json"],
                    "default": "markdown"
                }
            },
            "required": ["task"]
        })
    }

    #[allow(clippy::cast_possible_truncation)]
    fn execute(&self, params: Value) -> ToolResult {
        let task = params
            .get("task")
            .and_then(Value::as_str)
            .ok_or_else(|| ToolError::invalid_params("task must be a string"))?;

        let max_nodes = params
            .get("max_nodes")
            .and_then(Value::as_u64)
            .map(|n| n as usize);
        let max_code_blocks = params
            .get("max_code_blocks")
            .and_then(Value::as_u64)
            .map(|n| n as usize);
        let max_code_block_size = params
            .get("max_code_block_size")
            .and_then(Value::as_u64)
            .map(|n| n as usize);
        let include_code = params.get("include_code").and_then(Value::as_bool);
        let traversal_depth = params
            .get("traversal_depth")
            .and_then(Value::as_u64)
            .map(|n| n as usize);

        let format = match params.get("format").and_then(Value::as_str) {
            Some("json") => Some(ContextFormat::Json),
            Some("markdown") | None => Some(ContextFormat::Markdown),
            _ => None,
        };

        let options = BuildContextOptions {
            max_nodes,
            max_code_blocks,
            max_code_block_size,
            include_code,
            traversal_depth,
            format,
            search_limit: params
                .get("search_limit")
                .and_then(Value::as_u64)
                .map(|n| n as usize),
            min_score: params
                .get("min_score")
                .and_then(Value::as_f64)
                .map(|f| f as f32),
        };

        let context = context::build_context(&self.project_root, task, &options)
            .map_err(|e| ToolError::internal_error(format!("Failed to build context: {e}")))?;

        // If format is JSON, return structured data; otherwise return as text
        match format {
            Some(ContextFormat::Json) => {
                // Parse the JSON string back to Value
                serde_json::from_str(&context).map_err(|e| {
                    ToolError::internal_error(format!("Failed to parse context JSON: {e}"))
                })
            }
            _ => {
                // Return markdown as text content
                Ok(json!({
                    "context": context,
                    "format": "markdown"
                }))
            }
        }
    }
}