crowe-logic 0.1.0

package/scripts/test_agent.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+Crowe Logic Agent — Test Harness
+
+Runs a suite of test prompts across all domains to verify the agent
+works correctly with all tools. Tests auto-tool-selection, streaming,
+and multi-step reasoning.
+
+Usage:
+    python scripts/test_agent.py
+    python scripts/test_agent.py --quick     # Just 3 core tests
+    python scripts/test_agent.py --verbose   # Show full responses
+"""
+
+import os
+import sys
+import json
+import time
+import argparse
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from azure.ai.agents import AgentsClient
+from azure.ai.agents.models import (
+    FunctionTool, ToolSet, CodeInterpreterTool,
+    MessageDeltaChunk, ThreadMessage, ThreadRun, AgentStreamEvent,
+    ListSortOrder, MessageRole,
+)
+from azure.identity import DefaultAzureCredential
+
+from config.agent_config import PROJECT_ENDPOINT
+from tools import user_functions
+
+# ──────────────────────────────────────────────
+# Test prompts — each exercises a different tool
+# ──────────────────────────────────────────────
+
+TESTS = [
+    {
+        "name": "filesystem_read",
+        "prompt": "Read the file /Users/crowelogic/Projects/crowe-logic-foundry/requirements.txt and list the packages.",
+        "expect_tool": "read_file",
+        "domain": "filesystem",
+    },
+    {
+        "name": "directory_list",
+        "prompt": "List all Python files in /Users/crowelogic/Projects/crowe-logic-foundry/tools/",
+        "expect_tool": "list_directory",
+        "domain": "filesystem",
+    },
+    {
+        "name": "shell_command",
+        "prompt": "What version of Python is installed? Run python3 --version",
+        "expect_tool": "execute_shell",
+        "domain": "shell",
+    },
+    {
+        "name": "grep_search",
+        "prompt": "Search for all occurrences of 'def ' in /Users/crowelogic/Projects/crowe-logic-foundry/tools/filesystem.py",
+        "expect_tool": "grep_search",
+        "domain": "search",
+    },
+    {
+        "name": "web_search",
+        "prompt": "Search the web for 'gpt-oss-120b benchmark results'",
+        "expect_tool": "web_search",
+        "domain": "web",
+    },
+    {
+        "name": "browse_url",
+        "prompt": "Fetch the content of https://httpbin.org/json and tell me what it contains",
+        "expect_tool": "browse_url",
+        "domain": "web",
+    },
+    {
+        "name": "code_interpreter",
+        "prompt": "Use code interpreter to calculate the first 20 Fibonacci numbers and return them as a list.",
+        "expect_tool": "code_interpreter",
+        "domain": "code",
+    },
+    {
+        "name": "multi_step",
+        "prompt": "List the Python files in /Users/crowelogic/Projects/crowe-logic-foundry/tools/, then read each one and count the total number of functions defined across all files.",
+        "expect_tool": "multi_step",
+        "domain": "reasoning",
+    },
+]
+
+QUICK_TESTS = ["filesystem_read", "shell_command", "web_search"]
+
+
+def run_test(client, agent_id: str, test: dict, verbose: bool = False) -> dict:
+    """Run a single test and return results."""
+    thread = client.threads.create()
+    client.messages.create(thread_id=thread.id, role="user", content=test["prompt"])
+
+    start = time.time()
+    full_response = ""
+
+    # Use create_and_process for simpler test execution
+    run = client.runs.create_and_process(thread_id=thread.id, agent_id=agent_id)
+    elapsed = time.time() - start
+
+    # Get the response
+    messages = client.messages.list(thread_id=thread.id, order=ListSortOrder.ASCENDING)
+    for msg in messages:
+        if msg.role == MessageRole.AGENT and msg.text_messages:
+            full_response = msg.text_messages[-1].text.value
+
+    passed = len(full_response) > 10 and "error" not in full_response.lower()[:100]
+
+    result = {
+        "name": test["name"],
+        "domain": test["domain"],
+        "passed": passed,
+        "elapsed": round(elapsed, 2),
+        "response_length": len(full_response),
+        "run_status": run.status,
+    }
+
+    if verbose:
+        result["response_preview"] = full_response[:500]
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Test the Crowe Logic agent")
+    parser.add_argument("--quick", action="store_true", help="Run only 3 core tests")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Show response previews")
+    args = parser.parse_args()
+
+    # Load agent ID
+    agent_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".agent_id")
+    if not os.path.exists(agent_file):
+        print("ERROR: No agent deployed. Run: python scripts/create_agent.py")
+        sys.exit(1)
+
+    with open(agent_file) as f:
+        agent_id = json.load(f)["agent_id"]
+
+    # Connect
+    print(f"\n{'='*60}")
+    print(f"  CROWE LOGIC AGENT — TEST SUITE")
+    print(f"{'='*60}\n")
+
+    client = AgentsClient(
+        endpoint=PROJECT_ENDPOINT,
+        credential=DefaultAzureCredential(),
+    )
+
+    # Setup toolset
+    toolset = ToolSet()
+    toolset.add(FunctionTool(user_functions))
+    toolset.add(CodeInterpreterTool())
+    client.enable_auto_function_calls(toolset)
+
+    # Select tests
+    tests = TESTS
+    if args.quick:
+        tests = [t for t in TESTS if t["name"] in QUICK_TESTS]
+
+    print(f"  Running {len(tests)} tests against agent {agent_id[:20]}...\n")
+
+    # Run tests
+    results = []
+    for i, test in enumerate(tests, 1):
+        print(f"  [{i}/{len(tests)}] {test['name']:25s} ({test['domain']}) ... ", end="", flush=True)
+        try:
+            result = run_test(client, agent_id, test, verbose=args.verbose)
+            status = "PASS" if result["passed"] else "FAIL"
+            color = "" # no ANSI in basic print
+            print(f"{status}  ({result['elapsed']}s, {result['response_length']} chars)")
+            if args.verbose and "response_preview" in result:
+                print(f"         Response: {result['response_preview'][:200]}...")
+                print()
+        except Exception as e:
+            result = {"name": test["name"], "domain": test["domain"], "passed": False, "error": str(e)}
+            print(f"ERROR  ({str(e)[:60]})")
+        results.append(result)
+
+    # Summary
+    passed = sum(1 for r in results if r.get("passed"))
+    failed = len(results) - passed
+    print(f"\n{'='*60}")
+    print(f"  Results: {passed} passed, {failed} failed, {len(results)} total")
+    print(f"{'='*60}\n")
+
+    if failed > 0:
+        print("  Failed tests:")
+        for r in results:
+            if not r.get("passed"):
+                print(f"    - {r['name']}: {r.get('error', r.get('run_status', 'unknown'))}")
+        print()
+
+    sys.exit(0 if failed == 0 else 1)
+
+
+if __name__ == "__main__":
+    main()

package/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="crowe-logic",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "azure-ai-agents>=1.1.0",
+        "azure-identity>=1.17.0",
+        "click>=8.1.0",
+        "rich>=13.0.0",
+        "prompt-toolkit>=3.0.0",
+        "python-dotenv>=1.0.0",
+        "httpx>=0.27.0",
+        "beautifulsoup4>=4.12.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "crowe-logic=cli.crowe_logic:main",
+        ],
+    },
+    author="Michael Crowe",
+    description="Crowe Logic — Universal AI Agent powered by gpt-oss-120b on Azure AI Foundry",
+)

package/tools/__init__.py

@@ -0,0 +1,57 @@
+"""
+Crowe Logic Agent — Complete Tool Suite
+
+All functions are registered as FunctionTool with Azure AI Agent Service.
+The agent auto-selects and executes them based on the conversation.
+"""
+
+# Core tools (filesystem, shell, web)
+from tools.filesystem import read_file, write_file, edit_file, list_directory
+from tools.shell import execute_shell
+from tools.search import web_search, grep_search
+from tools.browser import browse_url
+
+# macOS automation
+from tools.applescript import run_applescript, open_application, send_notification
+
+# Git operations
+from tools.git_ops import git_status, git_diff, git_log, git_commit, git_clone
+
+# Browser automation (Playwright)
+from tools.playwright_browser import (
+    browser_navigate, browser_click, browser_type_text,
+    browser_snapshot, browser_screenshot,
+)
+
+# Talon Music Engine
+from tools.talon_music import (
+    talon_compose, talon_import_midi, talon_analyze,
+    talon_transform, talon_export,
+)
+
+# Quantum computing
+from tools.quantum import run_quantum_circuit, synapse_evaluate, qubit_flow_execute
+
+# All user-facing functions the agent can call
+user_functions = {
+    # Filesystem
+    read_file, write_file, edit_file, list_directory,
+    # Shell
+    execute_shell,
+    # Search
+    web_search, grep_search,
+    # Web browsing
+    browse_url,
+    # macOS
+    run_applescript, open_application, send_notification,
+    # Git
+    git_status, git_diff, git_log, git_commit, git_clone,
+    # Playwright browser
+    browser_navigate, browser_click, browser_type_text,
+    browser_snapshot, browser_screenshot,
+    # Talon Music
+    talon_compose, talon_import_midi, talon_analyze,
+    talon_transform, talon_export,
+    # Quantum
+    run_quantum_circuit, synapse_evaluate, qubit_flow_execute,
+}

package/tools/applescript.py

@@ -0,0 +1,58 @@
+"""
+AppleScript tool — macOS automation via osascript.
+"""
+
+import json
+import subprocess
+
+
+def run_applescript(script: str) -> str:
+    """
+    Execute an AppleScript and return the result. Can automate any macOS
+    application — Finder, Safari, Terminal, System Events, etc.
+
+    :param script: The AppleScript code to execute.
+    :return: JSON with the script output or error.
+    :rtype: str
+    """
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        return json.dumps({
+            "stdout": result.stdout.strip(),
+            "stderr": result.stderr.strip() if result.stderr else "",
+            "return_code": result.returncode,
+        })
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": "AppleScript timed out after 30s"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def open_application(app_name: str) -> str:
+    """
+    Open a macOS application by name. Works with any installed app.
+
+    :param app_name: Name of the application (e.g. "Ableton Live", "Safari", "Terminal").
+    :return: JSON confirmation.
+    :rtype: str
+    """
+    script = f'tell application "{app_name}" to activate'
+    return run_applescript(script)
+
+
+def send_notification(title: str, message: str) -> str:
+    """
+    Send a macOS notification with a title and message.
+
+    :param title: The notification title.
+    :param message: The notification body text.
+    :return: JSON confirmation.
+    :rtype: str
+    """
+    script = f'display notification "{message}" with title "{title}"'
+    return run_applescript(script)

package/tools/browser.py

@@ -0,0 +1,79 @@
+"""
+Browser tool — fetch and extract content from web pages.
+"""
+
+import json
+
+
+def browse_url(url: str, extract_mode: str = "text") -> str:
+    """
+    Fetch a web page and extract its content. Supports text extraction
+    and raw HTML modes.
+
+    :param url: The URL to fetch (must start with http:// or https://).
+    :param extract_mode: "text" for readable text, "html" for raw HTML, "links" for all links.
+    :return: JSON with the extracted page content.
+    :rtype: str
+    """
+    import httpx
+    from bs4 import BeautifulSoup
+
+    if not url.startswith(("http://", "https://")):
+        url = "https://" + url
+
+    try:
+        response = httpx.get(
+            url,
+            headers={
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) CroweLogic/0.1",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            },
+            timeout=20,
+            follow_redirects=True,
+        )
+        response.raise_for_status()
+
+        content_type = response.headers.get("content-type", "")
+        if "json" in content_type:
+            return json.dumps({
+                "url": str(response.url),
+                "status": response.status_code,
+                "content_type": "json",
+                "body": response.json(),
+            })
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Remove script, style, nav, footer noise
+        for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
+            tag.decompose()
+
+        if extract_mode == "html":
+            body = str(soup)[:100000]
+            return json.dumps({"url": str(response.url), "status": response.status_code, "html": body})
+
+        if extract_mode == "links":
+            links = []
+            for a in soup.find_all("a", href=True):
+                links.append({"text": a.get_text(strip=True)[:200], "href": a["href"]})
+            return json.dumps({"url": str(response.url), "status": response.status_code, "links": links[:200]})
+
+        # Default: text extraction
+        title = soup.title.string.strip() if soup.title and soup.title.string else ""
+        text = soup.get_text(separator="\n", strip=True)
+        # Collapse multiple blank lines
+        lines = [line for line in text.splitlines() if line.strip()]
+        text = "\n".join(lines)
+        if len(text) > 80000:
+            text = text[:80000] + "\n... (content truncated)"
+
+        return json.dumps({
+            "url": str(response.url),
+            "status": response.status_code,
+            "title": title,
+            "text": text,
+        })
+    except httpx.HTTPStatusError as e:
+        return json.dumps({"error": f"HTTP {e.response.status_code}: {str(e)}", "url": url})
+    except Exception as e:
+        return json.dumps({"error": str(e), "url": url})

package/tools/filesystem.py

@@ -0,0 +1,115 @@
+"""
+Filesystem tools — read, write, edit, and list files.
+"""
+
+import os
+import json
+from pathlib import Path
+
+
+def read_file(file_path: str, offset: int = 0, limit: int = 0) -> str:
+    """
+    Read the contents of a file. Returns the file content as a string.
+
+    :param file_path: Absolute path to the file to read.
+    :param offset: Line number to start reading from (0-based, default 0).
+    :param limit: Maximum number of lines to return (0 = unlimited).
+    :return: File contents with line numbers prefixed.
+    :rtype: str
+    """
+    path = Path(file_path).expanduser().resolve()
+    if not path.exists():
+        return json.dumps({"error": f"File not found: {file_path}"})
+    if not path.is_file():
+        return json.dumps({"error": f"Not a file: {file_path}"})
+    try:
+        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        if offset > 0:
+            lines = lines[offset:]
+        if limit > 0:
+            lines = lines[:limit]
+        numbered = [f"{i + offset + 1:>6}\t{line}" for i, line in enumerate(lines)]
+        return "\n".join(numbered)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def write_file(file_path: str, content: str) -> str:
+    """
+    Write content to a file, creating it if it doesn't exist.
+    Overwrites existing content.
+
+    :param file_path: Absolute path to the file to write.
+    :param content: The full content to write to the file.
+    :return: Confirmation message with bytes written.
+    :rtype: str
+    """
+    path = Path(file_path).expanduser().resolve()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        return json.dumps({"success": True, "path": str(path), "bytes": len(content.encode("utf-8"))})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def edit_file(file_path: str, old_string: str, new_string: str) -> str:
+    """
+    Replace an exact string in a file. The old_string must appear exactly once
+    in the file for the replacement to succeed.
+
+    :param file_path: Absolute path to the file to edit.
+    :param old_string: The exact text to find and replace.
+    :param new_string: The replacement text.
+    :return: Confirmation or error message.
+    :rtype: str
+    """
+    path = Path(file_path).expanduser().resolve()
+    if not path.exists():
+        return json.dumps({"error": f"File not found: {file_path}"})
+    try:
+        text = path.read_text(encoding="utf-8")
+        count = text.count(old_string)
+        if count == 0:
+            return json.dumps({"error": "old_string not found in file"})
+        if count > 1:
+            return json.dumps({"error": f"old_string found {count} times — must be unique. Provide more context."})
+        new_text = text.replace(old_string, new_string, 1)
+        path.write_text(new_text, encoding="utf-8")
+        return json.dumps({"success": True, "path": str(path)})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def list_directory(directory_path: str, pattern: str = "*", recursive: bool = False) -> str:
+    """
+    List files and directories at the given path. Supports glob patterns.
+
+    :param directory_path: Absolute path to the directory to list.
+    :param pattern: Glob pattern to filter results (default "*").
+    :param recursive: If true, search recursively using "**/" prefix.
+    :return: JSON list of file/directory entries with type and size.
+    :rtype: str
+    """
+    path = Path(directory_path).expanduser().resolve()
+    if not path.exists():
+        return json.dumps({"error": f"Directory not found: {directory_path}"})
+    if not path.is_dir():
+        return json.dumps({"error": f"Not a directory: {directory_path}"})
+    try:
+        if recursive:
+            entries = sorted(path.rglob(pattern))
+        else:
+            entries = sorted(path.glob(pattern))
+
+        results = []
+        for entry in entries[:500]:  # Cap at 500 to avoid huge outputs
+            results.append({
+                "name": entry.name,
+                "path": str(entry),
+                "type": "dir" if entry.is_dir() else "file",
+                "size": entry.stat().st_size if entry.is_file() else None,
+            })
+        return json.dumps({"count": len(results), "entries": results})
+    except Exception as e:
+        return json.dumps({"error": str(e)})

package/tools/git_ops.py

@@ -0,0 +1,107 @@
+"""
+Git operations tool — repo management, commits, branches, diffs.
+"""
+
+import json
+import subprocess
+import os
+
+
+def git_status(repo_path: str) -> str:
+    """
+    Show the working tree status of a git repository.
+
+    :param repo_path: Absolute path to the git repository.
+    :return: JSON with status output (staged, unstaged, untracked files).
+    :rtype: str
+    """
+    return _git(repo_path, ["status", "--porcelain=v2", "--branch"])
+
+
+def git_diff(repo_path: str, staged: bool = False) -> str:
+    """
+    Show changes in the working directory or staging area.
+
+    :param repo_path: Absolute path to the git repository.
+    :param staged: If true, show staged changes. Default shows unstaged.
+    :return: JSON with diff output.
+    :rtype: str
+    """
+    cmd = ["diff", "--stat"]
+    if staged:
+        cmd.append("--cached")
+    return _git(repo_path, cmd)
+
+
+def git_log(repo_path: str, count: int = 10) -> str:
+    """
+    Show recent commit history.
+
+    :param repo_path: Absolute path to the git repository.
+    :param count: Number of commits to show (default 10).
+    :return: JSON with commit history (hash, author, date, message).
+    :rtype: str
+    """
+    count = min(count, 50)
+    return _git(repo_path, ["log", f"-{count}", "--oneline", "--decorate"])
+
+
+def git_commit(repo_path: str, message: str, files: str = ".") -> str:
+    """
+    Stage files and create a commit.
+
+    :param repo_path: Absolute path to the git repository.
+    :param message: The commit message.
+    :param files: Files to stage (default "." for all changes).
+    :return: JSON with commit result.
+    :rtype: str
+    """
+    add_result = _git(repo_path, ["add", files])
+    if "error" in add_result:
+        return add_result
+    return _git(repo_path, ["commit", "-m", message])
+
+
+def git_clone(url: str, target_path: str) -> str:
+    """
+    Clone a git repository.
+
+    :param url: The repository URL to clone.
+    :param target_path: Local path to clone into.
+    :return: JSON with clone result.
+    :rtype: str
+    """
+    try:
+        result = subprocess.run(
+            ["git", "clone", url, target_path],
+            capture_output=True, text=True, timeout=120,
+        )
+        return json.dumps({
+            "stdout": result.stdout.strip(),
+            "stderr": result.stderr.strip(),
+            "return_code": result.returncode,
+        })
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def _git(repo_path: str, args: list) -> str:
+    """Run a git command in the given repo."""
+    repo = os.path.expanduser(repo_path)
+    if not os.path.isdir(os.path.join(repo, ".git")):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            capture_output=True, text=True, timeout=30, cwd=repo,
+        )
+        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 Exception as e:
+        return json.dumps({"error": str(e)})