crowe-logic 0.1.0

package/tools/playwright_browser.py

@@ -0,0 +1,101 @@
+"""
+Playwright browser automation tool — full browser control via MCP.
+Wraps the @playwright/mcp server as a locally callable tool.
+"""
+
+import json
+import subprocess
+
+
+def browser_navigate(url: str) -> str:
+    """
+    Navigate the browser to a URL and return the page accessibility snapshot.
+    Opens a browser if one isn't already running.
+
+    :param url: The URL to navigate to.
+    :return: JSON with page title and accessibility tree snapshot.
+    :rtype: str
+    """
+    return _run_playwright_action("browser_navigate", {"url": url})
+
+
+def browser_click(element: str, ref: str = "") -> str:
+    """
+    Click an element on the current page. Use the element description
+    or the ref ID from a previous snapshot.
+
+    :param element: Description of the element to click (e.g. "Submit button", "Login link").
+    :param ref: Optional element ref from accessibility snapshot.
+    :return: JSON result of the click action.
+    :rtype: str
+    """
+    args = {"element": element}
+    if ref:
+        args["ref"] = ref
+    return _run_playwright_action("browser_click", args)
+
+
+def browser_type_text(element: str, text: str, submit: bool = False) -> str:
+    """
+    Type text into an input field on the page.
+
+    :param element: Description of the input field (e.g. "Search box", "Email field").
+    :param text: The text to type.
+    :param submit: Whether to press Enter after typing (default False).
+    :return: JSON result of the type action.
+    :rtype: str
+    """
+    args = {"element": element, "text": text, "submit": submit}
+    return _run_playwright_action("browser_type", args)
+
+
+def browser_snapshot() -> str:
+    """
+    Get the current page's accessibility tree snapshot. This shows all
+    interactive elements, text content, and their ref IDs for clicking.
+
+    :return: JSON with the full page accessibility snapshot.
+    :rtype: str
+    """
+    return _run_playwright_action("browser_snapshot", {})
+
+
+def browser_screenshot(filename: str = "/tmp/screenshot.png") -> str:
+    """
+    Take a screenshot of the current browser page.
+
+    :param filename: Path to save the screenshot (default /tmp/screenshot.png).
+    :return: JSON with the screenshot file path.
+    :rtype: str
+    """
+    return _run_playwright_action("browser_take_screenshot", {"raw": True})
+
+
+def _run_playwright_action(tool_name: str, arguments: dict) -> str:
+    """Bridge to the Playwright MCP server via npx."""
+    try:
+        # Use the MCP server's stdio interface via a subprocess
+        mcp_input = json.dumps({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/call",
+            "params": {"name": tool_name, "arguments": arguments}
+        })
+
+        result = subprocess.run(
+            ["npx", "-y", "@playwright/mcp@latest", "--headless"],
+            input=mcp_input,
+            capture_output=True,
+            text=True,
+            timeout=30,
+            cwd="/Users/crowelogic/Projects/crowe-logic-foundry",
+        )
+
+        if result.stdout:
+            return result.stdout[:50000]
+        return json.dumps({"note": "Action sent to Playwright", "tool": tool_name, "args": arguments})
+
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": f"Playwright action timed out: {tool_name}"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})

package/tools/quantum.py

@@ -0,0 +1,89 @@
+"""
+Quantum computing tool — execute circuits via Qiskit, Cirq, PennyLane, and Synapse.
+"""
+
+import json
+
+
+def run_quantum_circuit(code: str, backend: str = "qiskit", shots: int = 1024) -> str:
+    """
+    Execute a quantum circuit using the specified backend.
+    Supports Qiskit (IBM Quantum), Cirq (Google), PennyLane, and Synapse-Lang.
+
+    :param code: Python code defining the quantum circuit. Must assign result to a variable called 'result'.
+    :param backend: Quantum framework (qiskit, cirq, pennylane, synapse).
+    :param shots: Number of measurement shots (default 1024).
+    :return: JSON with circuit execution results (counts, probabilities, statevector).
+    :rtype: str
+    """
+    try:
+        # Create a safe execution namespace with quantum imports
+        namespace = {"__builtins__": __builtins__, "shots": shots}
+
+        if backend == "qiskit":
+            import qiskit
+            from qiskit_aer import AerSimulator
+            namespace["QuantumCircuit"] = qiskit.QuantumCircuit
+            namespace["AerSimulator"] = AerSimulator
+        elif backend == "cirq":
+            import cirq
+            import numpy as np
+            namespace["cirq"] = cirq
+            namespace["np"] = np
+        elif backend == "pennylane":
+            import pennylane as qml
+            import numpy as np
+            namespace["qml"] = qml
+            namespace["np"] = np
+        elif backend == "synapse":
+            import synapse_lang
+            namespace["synapse_lang"] = synapse_lang
+
+        exec(code, namespace)
+
+        result = namespace.get("result", "No 'result' variable found. Assign your output to 'result'.")
+
+        # Serialize the result
+        if hasattr(result, "to_dict"):
+            return json.dumps({"backend": backend, "result": result.to_dict()})
+        else:
+            return json.dumps({"backend": backend, "result": str(result)})
+
+    except Exception as e:
+        return json.dumps({"error": str(e), "backend": backend})
+
+
+def synapse_evaluate(expression: str) -> str:
+    """
+    Evaluate a Synapse-Lang expression. Synapse is a quantum-classical
+    hybrid programming language created by Michael Crowe.
+
+    :param expression: A Synapse-Lang expression or program.
+    :return: JSON with the evaluation result.
+    :rtype: str
+    """
+    try:
+        from synapse_lang import SynapseLang
+        sl = SynapseLang()
+        result = sl.evaluate(expression)
+        return json.dumps({"expression": expression, "result": str(result)})
+    except Exception as e:
+        return json.dumps({"error": str(e), "expression": expression})
+
+
+def qubit_flow_execute(program: str) -> str:
+    """
+    Execute a Qubit-Flow program. Qubit-Flow is a quantum circuit design
+    language that's part of the Quantum Trinity (with Synapse-Lang).
+
+    :param program: A Qubit-Flow program string.
+    :return: JSON with execution results.
+    :rtype: str
+    """
+    try:
+        from qubit_flow_lang import QubitFlowInterpreter
+        interpreter = QubitFlowInterpreter()
+        result = interpreter.run(program)
+        return json.dumps({"program": program[:500], "result": str(result)})
+    except Exception as e:
+        return json.dumps({"error": str(e)})

package/tools/search.py

@@ -0,0 +1,108 @@
+"""
+Search tools — web search and local file content search (grep).
+"""
+
+import json
+import subprocess
+import os
+
+
+def web_search(query: str, num_results: int = 5) -> str:
+    """
+    Search the web using the system's available search capabilities.
+    Returns a list of search results with titles, URLs, and snippets.
+
+    :param query: The search query string.
+    :param num_results: Number of results to return (default 5, max 10).
+    :return: JSON list of search results.
+    :rtype: str
+    """
+    import httpx
+
+    num_results = min(num_results, 10)
+
+    # Use DuckDuckGo Lite as a free, no-API-key search fallback
+    try:
+        response = httpx.get(
+            "https://lite.duckduckgo.com/lite/",
+            params={"q": query},
+            headers={"User-Agent": "CroweLogic/0.1"},
+            timeout=15,
+            follow_redirects=True,
+        )
+        # Parse the lite HTML for result links
+        from bs4 import BeautifulSoup
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        results = []
+        for link in soup.select("a.result-link, td a[href^='http']"):
+            href = link.get("href", "")
+            text = link.get_text(strip=True)
+            if href.startswith("http") and text and len(results) < num_results:
+                results.append({"title": text, "url": href})
+
+        if results:
+            return json.dumps({"query": query, "results": results})
+
+        return json.dumps({"query": query, "results": [], "note": "No results found. Try rephrasing."})
+    except Exception as e:
+        return json.dumps({"error": f"Search failed: {str(e)}"})
+
+
+def grep_search(pattern: str, path: str = ".", file_glob: str = "", max_results: int = 50) -> str:
+    """
+    Search file contents using ripgrep (rg) or grep. Supports regex patterns.
+
+    :param pattern: Regex pattern to search for.
+    :param path: Directory or file to search in (default: current directory).
+    :param file_glob: Optional glob to filter files (e.g. "*.py", "*.ts").
+    :param max_results: Maximum number of matching lines to return (default 50).
+    :return: JSON with matching lines, file paths, and line numbers.
+    :rtype: str
+    """
+    search_path = os.path.expanduser(path)
+    max_results = min(max_results, 200)
+
+    # Prefer ripgrep, fall back to grep
+    rg_path = subprocess.run(["which", "rg"], capture_output=True, text=True).stdout.strip()
+
+    try:
+        if rg_path:
+            cmd = [rg_path, "--json", "-m", str(max_results), "--no-heading"]
+            if file_glob:
+                cmd.extend(["--glob", file_glob])
+            cmd.extend([pattern, search_path])
+        else:
+            cmd = ["grep", "-rn", "--include", file_glob or "*", pattern, search_path]
+
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+
+        if rg_path:
+            # Parse ripgrep JSON output
+            matches = []
+            for line in result.stdout.splitlines():
+                try:
+                    entry = json.loads(line)
+                    if entry.get("type") == "match":
+                        data = entry["data"]
+                        matches.append({
+                            "file": data["path"]["text"],
+                            "line_number": data["line_number"],
+                            "text": data["lines"]["text"].rstrip(),
+                        })
+                except json.JSONDecodeError:
+                    continue
+            return json.dumps({"pattern": pattern, "count": len(matches), "matches": matches})
+        else:
+            # Parse grep output
+            matches = []
+            for line in result.stdout.splitlines()[:max_results]:
+                parts = line.split(":", 2)
+                if len(parts) >= 3:
+                    matches.append({"file": parts[0], "line_number": int(parts[1]), "text": parts[2].rstrip()})
+            return json.dumps({"pattern": pattern, "count": len(matches), "matches": matches})
+
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": "Search timed out after 30s"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})

package/tools/shell.py

@@ -0,0 +1,47 @@
+"""
+Shell tool — execute commands locally.
+"""
+
+import json
+import subprocess
+
+
+def execute_shell(command: str, working_directory: str = "", timeout_seconds: int = 120) -> str:
+    """
+    Execute a shell command and return stdout, stderr, and exit code.
+    Commands run in a bash shell with a configurable timeout.
+
+    :param command: The shell command to execute.
+    :param working_directory: Directory to run the command in (default: home dir).
+    :param timeout_seconds: Max execution time in seconds (default 120, max 600).
+    :return: JSON with stdout, stderr, and return_code.
+    :rtype: str
+    """
+    import os
+
+    cwd = working_directory or os.path.expanduser("~")
+    timeout_seconds = min(timeout_seconds, 600)
+
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            timeout=timeout_seconds,
+            env={**os.environ, "TERM": "dumb"},
+        )
+        stdout = result.stdout
+        if len(stdout) > 50000:
+            stdout = stdout[:50000] + "\n... (output truncated at 50KB)"
+
+        return json.dumps({
+            "stdout": stdout,
+            "stderr": result.stderr[:10000] if result.stderr else "",
+            "return_code": result.returncode,
+        })
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": f"Command timed out after {timeout_seconds}s", "return_code": -1})
+    except Exception as e:
+        return json.dumps({"error": str(e), "return_code": -1})

package/tools/talon_music.py

@@ -0,0 +1,112 @@
+"""
+Talon Music Engine tool — quantum-powered composition via @talon/* packages.
+Interfaces with the Talon CLI and core libraries at ~/Projects/talon/.
+"""
+
+import json
+import subprocess
+import os
+
+TALON_PATH = "/Users/crowelogic/Projects/talon"
+
+
+def talon_compose(style: str = "ambient", duration_bars: int = 16, quantum_mode: str = "superposition") -> str:
+    """
+    Generate a musical composition using the Talon engine.
+    Leverages quantum-enhanced algorithms for creative variation.
+
+    :param style: Musical style (ambient, cinematic, electronic, jazz, experimental).
+    :param duration_bars: Length in bars (default 16).
+    :param quantum_mode: Quantum generation mode (superposition, entanglement, interference).
+    :return: JSON with composition data (MIDI events, structure, quantum metrics).
+    :rtype: str
+    """
+    return _run_talon_cli(["compose", "--style", style, "--bars", str(duration_bars), "--quantum", quantum_mode])
+
+
+def talon_import_midi(midi_path: str) -> str:
+    """
+    Import a MIDI file into Talon for analysis and transformation.
+
+    :param midi_path: Absolute path to the MIDI file.
+    :return: JSON with imported track data (notes, tempo, structure).
+    :rtype: str
+    """
+    return _run_talon_cli(["import", midi_path])
+
+
+def talon_analyze(input_source: str) -> str:
+    """
+    Analyze a MIDI file or Talon composition for musical properties.
+
+    :param input_source: Path to MIDI file or Talon composition ID.
+    :return: JSON with analysis (key, tempo, harmony, rhythm, complexity).
+    :rtype: str
+    """
+    return _run_talon_cli(["analyze", input_source])
+
+
+def talon_transform(input_source: str, transformation: str) -> str:
+    """
+    Apply a quantum transformation to a composition or MIDI file.
+
+    :param input_source: Path to MIDI file or Talon composition ID.
+    :param transformation: Transformation to apply (transpose, invert, retrograde, quantum-evolve, fractal-expand).
+    :return: JSON with transformed composition data.
+    :rtype: str
+    """
+    return _run_talon_cli(["transform", input_source, "--type", transformation])
+
+
+def talon_export(composition_id: str, format: str = "midi", output_path: str = "") -> str:
+    """
+    Export a Talon composition to a file.
+
+    :param composition_id: The composition ID to export.
+    :param format: Export format (midi, wav, json, ableton-als).
+    :param output_path: Optional output path (default: ~/Desktop/).
+    :return: JSON with export result and file path.
+    :rtype: str
+    """
+    cmd = ["export", composition_id, "--format", format]
+    if output_path:
+        cmd.extend(["--output", output_path])
+    return _run_talon_cli(cmd)
+
+
+def _run_talon_cli(args: list) -> str:
+    """Run a Talon CLI command."""
+    if not os.path.isdir(TALON_PATH):
+        return json.dumps({"error": f"Talon project not found at {TALON_PATH}"})
+
+    try:
+        # Try the CLI first, fall back to npx/node
+        result = subprocess.run(
+            ["npx", "talon"] + args,
+            capture_output=True, text=True, timeout=60,
+            cwd=TALON_PATH,
+            env={**os.environ, "NODE_PATH": os.path.join(TALON_PATH, "node_modules")},
+        )
+
+        if result.returncode != 0 and "not found" in result.stderr.lower():
+            # Fall back to direct node execution
+            cli_path = os.path.join(TALON_PATH, "packages", "cli", "src", "index.ts")
+            result = subprocess.run(
+                ["npx", "tsx", cli_path] + args,
+                capture_output=True, text=True, timeout=60,
+                cwd=TALON_PATH,
+            )
+
+        output = result.stdout.strip()
+        if len(output) > 50000:
+            output = output[:50000] + "\n... (truncated)"
+
+        return json.dumps({
+            "output": output,
+            "stderr": result.stderr.strip() if result.stderr else "",
+            "return_code": result.returncode,
+        })
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": "Talon command timed out after 60s"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})