ryeos-code 0.1.0__py3-none-any.whl

ryeos_code/.ai/tools/rye/code/git/git.py

@@ -0,0 +1,246 @@
+# rye:signed:2026-02-25T00:02:15Z:a23a1a0375614da586cad7d7dcaa6e27ebe4ddb16efad18e250643bd760bbf66:9SsOH5ZdKvZbv8v4xiFxMBRk4Q3ELA3x1TrMEtzITvI9e4ldiSZVsQbkk5ATYN5EegNOV3G4pvA_zBRKhANFBA==:9fbfabe975fa5a7f
+
+"""Git operations - status, add, commit, diff, log, branch, checkout, stash, reset, tag."""
+
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+__version__ = "1.0.0"
+__tool_type__ = "python"
+__executor_id__ = "rye/core/runtimes/python/script"
+__category__ = "rye/code/git"
+__tool_description__ = "Git operations - status, add, commit, diff, log, branch, checkout, stash, reset, tag"
+
+CONFIG_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "action": {
+            "type": "string",
+            "enum": ["status", "add", "commit", "diff", "log", "branch", "checkout", "stash", "reset", "tag"],
+            "description": "Git action to perform",
+        },
+        "args": {
+            "type": "array",
+            "items": {"type": "string"},
+            "default": [],
+            "description": "Arguments for the action (file paths, branch names, etc.)",
+        },
+        "message": {
+            "type": "string",
+            "description": "Commit/tag message (required for commit action)",
+        },
+        "flags": {
+            "type": "object",
+            "default": {},
+            "description": "Flags to pass (e.g. { staged: true, amend: true, create: true })",
+        },
+        "working_dir": {
+            "type": "string",
+            "description": "Working directory (relative to project root or absolute)",
+        },
+        "timeout": {
+            "type": "integer",
+            "default": 30,
+            "description": "Timeout in seconds",
+        },
+    },
+    "required": ["action"],
+}
+
+MAX_OUTPUT_BYTES = 51200
+DEFAULT_TIMEOUT = 30
+
+
+def truncate_output(output: str, max_bytes: int) -> tuple[str, bool]:
+    encoded = output.encode("utf-8", errors="replace")
+    if len(encoded) <= max_bytes:
+        return output, False
+
+    truncated_bytes = encoded[:max_bytes]
+    truncated_str = truncated_bytes.decode("utf-8", errors="replace")
+
+    truncation_msg = f"\n... [output truncated, {len(encoded)} bytes total]"
+    return truncated_str + truncation_msg, True
+
+
+def build_command(params: dict) -> list[str]:
+    action = params["action"]
+    args = params.get("args", [])
+    flags = params.get("flags", {})
+    message = params.get("message")
+
+    match action:
+        case "status":
+            cmd = ["git", "status", "--porcelain"]
+            if flags.get("long"):
+                cmd = ["git", "status"]
+            return cmd + args
+
+        case "add":
+            if not args:
+                raise ValueError("add requires explicit file paths")
+            blocked = {"-A", "--all", "."}
+            for a in args:
+                if a in blocked:
+                    raise ValueError("Use explicit file paths instead of '-A', '--all', or '.'")
+            return ["git", "add"] + args
+
+        case "commit":
+            if not message:
+                raise ValueError("commit requires a message")
+            cmd = ["git", "commit", "-m", message]
+            if flags.get("no_verify"):
+                cmd.append("--no-verify")
+            if flags.get("amend"):
+                cmd.append("--amend")
+            return cmd
+
+        case "diff":
+            cmd = ["git", "diff"]
+            if flags.get("staged") or flags.get("cached"):
+                cmd.append("--staged")
+            return cmd + args
+
+        case "log":
+            max_count = flags.get("max_count", 20)
+            cmd = ["git", "log", "--oneline", f"-n{max_count}"]
+            if flags.get("format"):
+                cmd = ["git", "log", f"--format={flags['format']}", f"-n{max_count}"]
+            return cmd + args
+
+        case "branch":
+            if flags.get("delete") and args:
+                return ["git", "branch", "-d", args[0]]
+            if flags.get("list") or not args:
+                cmd = ["git", "branch"]
+                if flags.get("all"):
+                    cmd.append("-a")
+                return cmd
+            return ["git", "branch", args[0]]
+
+        case "checkout":
+            if not args:
+                raise ValueError("checkout requires a branch or file path")
+            cmd = ["git", "checkout"]
+            if flags.get("create"):
+                cmd.append("-b")
+            return cmd + args
+
+        case "stash":
+            sub = args[0] if args else "push"
+            valid = {"push", "pop", "list", "drop", "apply"}
+            if sub not in valid:
+                raise ValueError(f"Invalid stash subcommand: {sub}. Valid: {', '.join(sorted(valid))}")
+            cmd = ["git", "stash", sub]
+            return cmd + args[1:]
+
+        case "reset":
+            cmd = ["git", "reset"]
+            if flags.get("hard"):
+                cmd.append("--hard")
+            elif flags.get("soft"):
+                cmd.append("--soft")
+            elif flags.get("mixed"):
+                cmd.append("--mixed")
+            return cmd + args
+
+        case "tag":
+            if flags.get("list") or (flags.get("delete") is None and not args):
+                return ["git", "tag", "--list"]
+            if flags.get("delete") and args:
+                return ["git", "tag", "-d", args[0]]
+            if not args:
+                raise ValueError("tag requires a tag name")
+            cmd = ["git", "tag"]
+            if flags.get("message"):
+                cmd.extend(["-a", args[0], "-m", flags["message"]])
+            else:
+                cmd.append(args[0])
+            return cmd
+
+        case _:
+            raise ValueError(f"Unknown action: {action}")
+
+
+def execute(params: dict, project_path: str) -> dict:
+    project = Path(project_path).resolve()
+    timeout = params.get("timeout", DEFAULT_TIMEOUT)
+    working_dir = params.get("working_dir")
+
+    if working_dir:
+        work_path = Path(working_dir)
+        if not work_path.is_absolute():
+            work_path = project / work_path
+        work_path = work_path.resolve()
+
+        if not work_path.is_relative_to(project):
+            return {
+                "success": False,
+                "error": "Working directory is outside the project workspace",
+            }
+
+        if not work_path.exists():
+            return {
+                "success": False,
+                "error": f"Working directory not found: {work_path}",
+            }
+    else:
+        work_path = project
+
+    try:
+        cmd = build_command(params)
+    except ValueError as e:
+        return {"success": False, "error": str(e)}
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=str(work_path),
+            timeout=timeout,
+        )
+
+        stdout = result.stdout or ""
+        stderr = result.stderr or ""
+
+        stdout, stdout_truncated = truncate_output(stdout, MAX_OUTPUT_BYTES)
+        stderr, stderr_truncated = truncate_output(stderr, MAX_OUTPUT_BYTES)
+
+        success = result.returncode == 0
+
+        output_parts = []
+        if stdout:
+            output_parts.append(stdout)
+        if stderr:
+            output_parts.append(f"[stderr]\n{stderr}")
+
+        combined_output = "\n".join(output_parts)
+
+        return {
+            "success": success,
+            "output": combined_output,
+            "stdout": stdout,
+            "stderr": stderr,
+            "exit_code": result.returncode,
+            "truncated": stdout_truncated or stderr_truncated,
+        }
+    except subprocess.TimeoutExpired:
+        return {
+            "success": False,
+            "error": f"Command timed out after {timeout} seconds",
+            "timeout": timeout,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--params", required=True)
+    parser.add_argument("--project-path", required=True)
+    args = parser.parse_args()
+    result = execute(json.loads(args.params), args.project_path)
+    print(json.dumps(result))

ryeos_code/.ai/tools/rye/code/lsp/lsp.ts

@@ -0,0 +1,438 @@
+// rye:signed:2026-02-25T00:02:14Z:86f089cf310d3ff22be3f65d2768cea1e3c568955b4276605c3911d67bdd8b9e:U6Mjpa8FTWO519-6nqdILwMJIlNu_D6gKS2Uu3AgJmS4mWgI_DWOH-jtNWW8A_WSpRJbXqRiH88cA9CVaeXrAQ==:9fbfabe975fa5a7f
+// rye:unsigned
+import { parseArgs } from "node:util";
+import { spawn } from "node:child_process";
+import { resolve, isAbsolute, extname, relative } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import {
+  createMessageConnection,
+  StreamMessageReader,
+  StreamMessageWriter,
+} from "vscode-jsonrpc/node.js";
+
+export const __version__ = "1.0.0";
+export const __tool_type__ = "javascript";
+export const __executor_id__ = "rye/core/runtimes/node/node";
+export const __category__ = "rye/code/lsp";
+export const __tool_description__ =
+  "LSP client — go to definition, find references, hover, document symbols, and more via language servers";
+
+const OPERATIONS = [
+  "goToDefinition",
+  "findReferences",
+  "hover",
+  "documentSymbol",
+  "workspaceSymbol",
+  "goToImplementation",
+  "prepareCallHierarchy",
+  "incomingCalls",
+  "outgoingCalls",
+] as const;
+
+export const CONFIG_SCHEMA = {
+  type: "object",
+  properties: {
+    operation: {
+      type: "string",
+      enum: [...OPERATIONS],
+      description: "LSP operation to perform",
+    },
+    file_path: {
+      type: "string",
+      description: "Path to the file",
+    },
+    line: {
+      type: "integer",
+      minimum: 1,
+      description: "Line number (1-based)",
+    },
+    character: {
+      type: "integer",
+      minimum: 1,
+      description: "Character offset (1-based)",
+    },
+    timeout: {
+      type: "integer",
+      default: 15,
+      description: "Timeout in seconds",
+    },
+  },
+  required: ["operation", "file_path", "line", "character"],
+};
+
+const DEFAULT_TIMEOUT = 15;
+
+const LANGUAGE_EXTENSIONS: Record<string, string> = {
+  ".py": "python",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".java": "java",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".vue": "vue",
+  ".svelte": "svelte",
+};
+
+interface ServerConfig {
+  id: string;
+  extensions: string[];
+  command: string[];
+}
+
+const SERVERS: ServerConfig[] = [
+  {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    command: ["typescript-language-server", "--stdio"],
+  },
+  {
+    id: "pyright",
+    extensions: [".py"],
+    command: ["pyright-langserver", "--stdio"],
+  },
+  {
+    id: "gopls",
+    extensions: [".go"],
+    command: ["gopls", "serve"],
+  },
+  {
+    id: "rust-analyzer",
+    extensions: [".rs"],
+    command: ["rust-analyzer"],
+  },
+];
+
+interface Params {
+  operation: (typeof OPERATIONS)[number];
+  file_path: string;
+  line: number;
+  character: number;
+  timeout?: number;
+}
+
+interface Result {
+  success: boolean;
+  output?: string;
+  error?: string;
+  operation?: string;
+  server?: string;
+  results?: unknown[];
+}
+
+function findServer(filePath: string): ServerConfig | null {
+  const ext = extname(filePath).toLowerCase();
+  for (const server of SERVERS) {
+    if (!server.extensions.includes(ext)) continue;
+    try {
+      execSync(`which ${server.command[0]}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      return server;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`Timed out after ${ms}ms`)),
+      ms,
+    );
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      },
+    );
+  });
+}
+
+async function execute(params: Params, projectPath: string): Promise<Result> {
+  const project = resolve(projectPath);
+  const operation = params.operation;
+  const timeout = (params.timeout ?? DEFAULT_TIMEOUT) * 1000;
+
+  let filePath = params.file_path;
+  if (!isAbsolute(filePath)) filePath = resolve(project, filePath);
+
+  if (!existsSync(filePath)) {
+    return { success: false, error: `File not found: ${filePath}` };
+  }
+
+  const server = findServer(filePath);
+  if (!server) {
+    return {
+      success: false,
+      error: `No LSP server available for ${extname(filePath)} files`,
+    };
+  }
+
+  const proc = spawn(server.command[0], server.command.slice(1), {
+    cwd: project,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  const connection = createMessageConnection(
+    new StreamMessageReader(proc.stdout),
+    new StreamMessageWriter(proc.stdin),
+  );
+
+  // Suppress unhandled notifications
+  connection.onRequest("window/workDoneProgress/create", () => null);
+  connection.onRequest("workspace/configuration", () => [{}]);
+  connection.onRequest("client/registerCapability", () => {});
+  connection.onRequest("client/unregisterCapability", () => {});
+  connection.onRequest("workspace/workspaceFolders", () => [
+    { name: "workspace", uri: pathToFileURL(project).href },
+  ]);
+
+  connection.listen();
+
+  try {
+    // Initialize
+    await withTimeout(
+      connection.sendRequest("initialize", {
+        rootUri: pathToFileURL(project).href,
+        processId: proc.pid,
+        workspaceFolders: [
+          { name: "workspace", uri: pathToFileURL(project).href },
+        ],
+        capabilities: {
+          workspace: {
+            configuration: true,
+            didChangeWatchedFiles: { dynamicRegistration: true },
+          },
+          textDocument: {
+            synchronization: { didOpen: true, didChange: true },
+            publishDiagnostics: { versionSupport: true },
+          },
+        },
+      }),
+      timeout,
+    );
+
+    await connection.sendNotification("initialized", {});
+
+    // Open file
+    const ext = extname(filePath);
+    const languageId = LANGUAGE_EXTENSIONS[ext] ?? "plaintext";
+    const text = readFileSync(filePath, "utf-8");
+    const uri = pathToFileURL(filePath).href;
+
+    await connection.sendNotification("textDocument/didOpen", {
+      textDocument: { uri, languageId, version: 0, text },
+    });
+
+    // Brief delay for server to process
+    await new Promise((r) => setTimeout(r, 500));
+
+    const position = {
+      line: params.line - 1,
+      character: params.character - 1,
+    };
+    const textDocument = { uri };
+
+    // Execute operation
+    let results: unknown[];
+    switch (operation) {
+      case "goToDefinition":
+        results = await withTimeout(
+          connection
+            .sendRequest("textDocument/definition", { textDocument, position })
+            .then(normalize),
+          timeout,
+        );
+        break;
+      case "findReferences":
+        results = await withTimeout(
+          connection
+            .sendRequest("textDocument/references", {
+              textDocument,
+              position,
+              context: { includeDeclaration: true },
+            })
+            .then(normalize),
+          timeout,
+        );
+        break;
+      case "hover":
+        results = await withTimeout(
+          connection
+            .sendRequest("textDocument/hover", { textDocument, position })
+            .then((r) => (r ? [r] : [])),
+          timeout,
+        );
+        break;
+      case "documentSymbol":
+        results = await withTimeout(
+          connection
+            .sendRequest("textDocument/documentSymbol", { textDocument })
+            .then(normalize),
+          timeout,
+        );
+        break;
+      case "workspaceSymbol":
+        results = await withTimeout(
+          connection
+            .sendRequest("workspace/symbol", { query: "" })
+            .then(normalize)
+            .then((r: any[]) => r.slice(0, 20)),
+          timeout,
+        );
+        break;
+      case "goToImplementation":
+        results = await withTimeout(
+          connection
+            .sendRequest("textDocument/implementation", {
+              textDocument,
+              position,
+            })
+            .then(normalize),
+          timeout,
+        );
+        break;
+      case "prepareCallHierarchy":
+        results = await withTimeout(
+          connection
+            .sendRequest("textDocument/prepareCallHierarchy", {
+              textDocument,
+              position,
+            })
+            .then(normalize),
+          timeout,
+        );
+        break;
+      case "incomingCalls": {
+        const items: any[] = await withTimeout(
+          connection
+            .sendRequest("textDocument/prepareCallHierarchy", {
+              textDocument,
+              position,
+            })
+            .catch(() => []),
+          timeout,
+        );
+        if (!items?.length) {
+          results = [];
+        } else {
+          results = await withTimeout(
+            connection
+              .sendRequest("callHierarchy/incomingCalls", { item: items[0] })
+              .then(normalize),
+            timeout,
+          );
+        }
+        break;
+      }
+      case "outgoingCalls": {
+        const items2: any[] = await withTimeout(
+          connection
+            .sendRequest("textDocument/prepareCallHierarchy", {
+              textDocument,
+              position,
+            })
+            .catch(() => []),
+          timeout,
+        );
+        if (!items2?.length) {
+          results = [];
+        } else {
+          results = await withTimeout(
+            connection
+              .sendRequest("callHierarchy/outgoingCalls", { item: items2[0] })
+              .then(normalize),
+            timeout,
+          );
+        }
+        break;
+      }
+      default:
+        return { success: false, error: `Unknown operation: ${operation}` };
+    }
+
+    // Convert file URIs to relative paths
+    const cleaned = JSON.parse(
+      JSON.stringify(results, (key, value) => {
+        if (
+          key === "uri" &&
+          typeof value === "string" &&
+          value.startsWith("file://")
+        ) {
+          try {
+            return relative(project, fileURLToPath(value));
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      }),
+    );
+
+    const output =
+      cleaned.length === 0
+        ? `No results found for ${operation}`
+        : JSON.stringify(cleaned, null, 2);
+
+    const relPath = relative(project, filePath);
+    return {
+      success: true,
+      output,
+      operation,
+      server: server.id,
+      results: cleaned,
+    };
+  } catch (e: any) {
+    return {
+      success: false,
+      error: e.message ?? String(e),
+      operation,
+      server: server.id,
+    };
+  } finally {
+    connection.end();
+    connection.dispose();
+    proc.kill();
+  }
+}
+
+function normalize(result: unknown): unknown[] {
+  if (!result) return [];
+  return Array.isArray(result) ? result.filter(Boolean) : [result];
+}
+
+// CLI entry point
+const { values } = parseArgs({
+  options: {
+    params: { type: "string" },
+    "project-path": { type: "string" },
+  },
+});
+
+if (values.params && values["project-path"]) {
+  const result = await execute(
+    JSON.parse(values.params) as Params,
+    values["project-path"],
+  );
+  console.log(JSON.stringify(result));
+}