feat: add internal ZCLAW kernel crates to git tracking

crates/zclaw-runtime/src/tool/builtin/file_read.rs

@@ -0,0 +1,55 @@
+//! File read tool
+
+use async_trait::async_trait;
+use serde_json::{json, Value};
+use zclaw_types::{Result, ZclawError};
+
+use crate::tool::{Tool, ToolContext};
+
+pub struct FileReadTool;
+
+impl FileReadTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[async_trait]
+impl Tool for FileReadTool {
+    fn name(&self) -> &str {
+        "file_read"
+    }
+
+    fn description(&self) -> &str {
+        "Read the contents of a file from the filesystem"
+    }
+
+    fn input_schema(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The path to the file to read"
+                }
+            },
+            "required": ["path"]
+        })
+    }
+
+    async fn execute(&self, input: Value, _context: &ToolContext) -> Result<Value> {
+        let path = input["path"].as_str()
+            .ok_or_else(|| ZclawError::InvalidInput("Missing 'path' parameter".into()))?;
+
+        // TODO: Implement actual file reading with path validation
+        Ok(json!({
+            "content": format!("File content placeholder for: {}", path)
+        }))
+    }
+}
+
+impl Default for FileReadTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/zclaw-runtime/src/tool/builtin/file_write.rs

@@ -0,0 +1,62 @@
+//! File write tool
+
+use async_trait::async_trait;
+use serde_json::{json, Value};
+use zclaw_types::{Result, ZclawError};
+
+use crate::tool::{Tool, ToolContext};
+
+pub struct FileWriteTool;
+
+impl FileWriteTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[async_trait]
+impl Tool for FileWriteTool {
+    fn name(&self) -> &str {
+        "file_write"
+    }
+
+    fn description(&self) -> &str {
+        "Write content to a file on the filesystem"
+    }
+
+    fn input_schema(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The path to the file to write"
+                },
+                "content": {
+                    "type": "string",
+                    "description": "The content to write to the file"
+                }
+            },
+            "required": ["path", "content"]
+        })
+    }
+
+    async fn execute(&self, input: Value, _context: &ToolContext) -> Result<Value> {
+        let path = input["path"].as_str()
+            .ok_or_else(|| ZclawError::InvalidInput("Missing 'path' parameter".into()))?;
+        let content = input["content"].as_str()
+            .ok_or_else(|| ZclawError::InvalidInput("Missing 'content' parameter".into()))?;
+
+        // TODO: Implement actual file writing with path validation
+        Ok(json!({
+            "success": true,
+            "bytes_written": content.len()
+        }))
+    }
+}
+
+impl Default for FileWriteTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/zclaw-runtime/src/tool/builtin/shell_exec.rs

@@ -0,0 +1,61 @@
+//! Shell execution tool
+
+use async_trait::async_trait;
+use serde_json::{json, Value};
+use zclaw_types::{Result, ZclawError};
+
+use crate::tool::{Tool, ToolContext};
+
+pub struct ShellExecTool;
+
+impl ShellExecTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[async_trait]
+impl Tool for ShellExecTool {
+    fn name(&self) -> &str {
+        "shell_exec"
+    }
+
+    fn description(&self) -> &str {
+        "Execute a shell command and return the output"
+    }
+
+    fn input_schema(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The command to execute"
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds (default: 30)"
+                }
+            },
+            "required": ["command"]
+        })
+    }
+
+    async fn execute(&self, input: Value, _context: &ToolContext) -> Result<Value> {
+        let command = input["command"].as_str()
+            .ok_or_else(|| ZclawError::InvalidInput("Missing 'command' parameter".into()))?;
+
+        // TODO: Implement actual shell execution with security constraints
+        Ok(json!({
+            "stdout": format!("Command output placeholder for: {}", command),
+            "stderr": "",
+            "exit_code": 0
+        }))
+    }
+}
+
+impl Default for ShellExecTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/zclaw-runtime/src/tool/builtin/web_fetch.rs

@@ -0,0 +1,61 @@
+//! Web fetch tool
+
+use async_trait::async_trait;
+use serde_json::{json, Value};
+use zclaw_types::{Result, ZclawError};
+
+use crate::tool::{Tool, ToolContext};
+
+pub struct WebFetchTool;
+
+impl WebFetchTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[async_trait]
+impl Tool for WebFetchTool {
+    fn name(&self) -> &str {
+        "web_fetch"
+    }
+
+    fn description(&self) -> &str {
+        "Fetch content from a URL"
+    }
+
+    fn input_schema(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "The URL to fetch"
+                },
+                "method": {
+                    "type": "string",
+                    "enum": ["GET", "POST"],
+                    "description": "HTTP method (default: GET)"
+                }
+            },
+            "required": ["url"]
+        })
+    }
+
+    async fn execute(&self, input: Value, _context: &ToolContext) -> Result<Value> {
+        let url = input["url"].as_str()
+            .ok_or_else(|| ZclawError::InvalidInput("Missing 'url' parameter".into()))?;
+
+        // TODO: Implement actual web fetching with SSRF protection
+        Ok(json!({
+            "status": 200,
+            "content": format!("Fetched content placeholder for: {}", url)
+        }))
+    }
+}
+
+impl Default for WebFetchTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}