ltcai 0.1.8 → 0.1.11

package/tests/unit/test_tools.py

@@ -5,7 +5,28 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from tools import local_list, local_read, local_write, read_document, ToolError
+import tools as tools_module
+from tools import (
+    ToolError,
+    edit_file,
+    grep,
+    local_list,
+    local_read,
+    local_write,
+    read_document,
+    read_file,
+    todo_read,
+    todo_write,
+    write_file,
+)
+
+
+@pytest.fixture
+def workspace(tmp_path, monkeypatch):
+    """Redirect tools' AGENT_ROOT to a temp directory for the duration of a test."""
+    monkeypatch.setattr(tools_module, "AGENT_ROOT", tmp_path)
+    tools_module.ensure_agent_root()
+    return tmp_path
 
 
 # ---------------------------------------------------------------------------
@@ -125,3 +146,175 @@ def test_read_document_csv(tmp_path):
     result = read_document(str(f))
     # should not raise; returns some text content
     assert result is not None
+
+
+# ---------------------------------------------------------------------------
+# read_file (workspace, with line numbers and offset/limit)
+# ---------------------------------------------------------------------------
+
+def test_read_file_returns_numbered_view(workspace):
+    (workspace / "a.txt").write_text("alpha\nbeta\ngamma\n")
+    result = read_file("a.txt")
+    assert result["total_lines"] == 3
+    assert result["start_line"] == 1
+    assert result["end_line"] == 3
+    assert "1\talpha" in result["numbered"]
+    assert "3\tgamma" in result["numbered"]
+
+
+def test_read_file_offset_and_limit(workspace):
+    (workspace / "a.txt").write_text("\n".join(f"line{i}" for i in range(1, 11)))
+    result = read_file("a.txt", offset=3, limit=2)
+    assert result["start_line"] == 4
+    assert result["end_line"] == 5
+    assert result["content"].splitlines() == ["line4", "line5"]
+
+
+def test_read_file_disable_line_numbers(workspace):
+    (workspace / "a.txt").write_text("only\n")
+    result = read_file("a.txt", line_numbers=False)
+    assert "numbered" not in result
+    assert result["content"] == "only\n"
+
+
+# ---------------------------------------------------------------------------
+# edit_file
+# ---------------------------------------------------------------------------
+
+def test_edit_file_replaces_unique_match(workspace):
+    (workspace / "code.py").write_text("def foo():\n    return 1\n")
+    result = edit_file("code.py", "return 1", "return 42")
+    assert (workspace / "code.py").read_text() == "def foo():\n    return 42\n"
+    assert result["replacements"] == 1
+    assert result["first_edit_line"] == 2
+
+
+def test_edit_file_missing_string_raises(workspace):
+    (workspace / "code.py").write_text("hello\n")
+    with pytest.raises(ToolError, match="not found"):
+        edit_file("code.py", "missing", "world")
+
+
+def test_edit_file_ambiguous_raises_unless_replace_all(workspace):
+    (workspace / "code.py").write_text("x = 1\nx = 1\n")
+    with pytest.raises(ToolError, match="ambiguous"):
+        edit_file("code.py", "x = 1", "x = 2")
+    result = edit_file("code.py", "x = 1", "x = 2", replace_all=True)
+    assert result["replacements"] == 2
+    assert (workspace / "code.py").read_text() == "x = 2\nx = 2\n"
+
+
+def test_edit_file_rejects_identical(workspace):
+    (workspace / "code.py").write_text("same\n")
+    with pytest.raises(ToolError, match="identical"):
+        edit_file("code.py", "same", "same")
+
+
+# ---------------------------------------------------------------------------
+# grep
+# ---------------------------------------------------------------------------
+
+def test_grep_finds_regex_matches(workspace):
+    (workspace / "a.py").write_text("def foo():\n    return 1\n\ndef bar():\n    return 2\n")
+    (workspace / "b.py").write_text("x = 1\n")
+    result = grep(r"^def \w+", path=".")
+    paths = sorted({m["path"] for m in result["matches"]})
+    assert "a.py" in paths
+    assert result["files_with_matches"] == 1
+
+
+def test_grep_respects_glob(workspace):
+    (workspace / "a.py").write_text("needle\n")
+    (workspace / "a.txt").write_text("needle\n")
+    result = grep("needle", path=".", glob="*.py")
+    paths = [m["path"] for m in result["matches"]]
+    assert "a.py" in paths
+    assert "a.txt" not in paths
+
+
+def test_grep_case_insensitive(workspace):
+    (workspace / "a.txt").write_text("HELLO world\n")
+    result = grep("hello", path=".", case_insensitive=True)
+    assert any("HELLO" in m["match"] for m in result["matches"])
+
+
+def test_grep_context_lines(workspace):
+    (workspace / "a.txt").write_text("before\nhit\nafter\n")
+    result = grep("hit", path=".", context_lines=1)
+    assert result["matches"]
+    ctx_lines = [c["text"] for c in result["matches"][0]["context"]]
+    assert "before" in ctx_lines and "after" in ctx_lines
+
+
+def test_grep_invalid_regex_raises(workspace):
+    (workspace / "a.txt").write_text("hello\n")
+    with pytest.raises(ToolError, match="regex"):
+        grep("[unterminated", path=".")
+
+
+def test_grep_skips_binary_dirs(workspace):
+    (workspace / "node_modules").mkdir()
+    (workspace / "node_modules" / "x.js").write_text("needle\n")
+    (workspace / "src.py").write_text("needle\n")
+    result = grep("needle", path=".")
+    paths = [m["path"] for m in result["matches"]]
+    assert "src.py" in paths
+    assert all("node_modules" not in p for p in paths)
+
+
+# ---------------------------------------------------------------------------
+# todo_read / todo_write
+# ---------------------------------------------------------------------------
+
+def test_todo_read_empty_when_unset(workspace):
+    result = todo_read()
+    assert result["todos"] == []
+
+
+def test_todo_write_round_trip(workspace):
+    todos = [
+        {"id": "1", "content": "design API", "status": "completed"},
+        {"id": "2", "content": "write tests", "status": "in_progress"},
+        {"id": "3", "content": "deploy", "status": "pending"},
+    ]
+    todo_write(todos)
+    fresh = todo_read()
+    assert [t["content"] for t in fresh["todos"]] == ["design API", "write tests", "deploy"]
+    assert fresh["todos"][1]["status"] == "in_progress"
+
+
+def test_todo_write_rejects_invalid_status(workspace):
+    with pytest.raises(ToolError, match="status"):
+        todo_write([{"id": "1", "content": "x", "status": "blocked"}])
+
+
+def test_todo_write_rejects_missing_content(workspace):
+    with pytest.raises(ToolError, match="content"):
+        todo_write([{"id": "1", "content": "", "status": "pending"}])
+
+
+def test_todo_write_warns_multiple_in_progress(workspace):
+    result = todo_write([
+        {"id": "1", "content": "a", "status": "in_progress"},
+        {"id": "2", "content": "b", "status": "in_progress"},
+    ])
+    assert result["warning"]
+
+
+# ---------------------------------------------------------------------------
+# Sandbox: workspace tools must not escape AGENT_ROOT
+# ---------------------------------------------------------------------------
+
+def test_read_file_blocks_path_escape(workspace):
+    with pytest.raises(ToolError, match="escapes"):
+        read_file("../../etc/passwd")
+
+
+def test_edit_file_blocks_path_escape(workspace):
+    with pytest.raises(ToolError, match="escapes"):
+        edit_file("../../etc/passwd", "a", "b")
+
+
+def test_grep_blocks_path_escape(workspace):
+    with pytest.raises(ToolError, match="escapes"):
+        grep("x", path="../../etc")

package/tools.py

@@ -347,7 +347,15 @@ def workspace_tree(path: str = ".", max_depth: int = 3) -> Dict[str, Any]:
     return {"root": str(AGENT_ROOT), "path": _relative(target) if target != AGENT_ROOT else ".", "entries": entries}
 
 
-def read_file(path: str) -> Dict[str, Any]:
+def read_file(path: str, offset: int = 0, limit: int = 0, line_numbers: bool = True) -> Dict[str, Any]:
+    """Read a file from the agent workspace.
+
+    Returns content as plain text. When line_numbers is True (default), also
+    returns a numbered view (`numbered`) plus `total_lines` so the agent can
+    cite file:line locations precisely.
+
+    offset is 0-indexed (the first line is offset=0). limit=0 reads to the end.
+    """
     target = _resolve_path(path)
     if not target.exists():
         raise ToolError("File does not exist.")
@@ -356,7 +364,31 @@ def read_file(path: str) -> Dict[str, Any]:
     size = target.stat().st_size
     if size > MAX_FILE_BYTES:
         raise ToolError(f"File is too large to read ({size} bytes).")
-    return {"path": _relative(target), "content": target.read_text(encoding="utf-8")}
+    text = target.read_text(encoding="utf-8")
+    all_lines = text.splitlines()
+    total_lines = len(all_lines)
+
+    offset = max(0, int(offset or 0))
+    limit = max(0, int(limit or 0))
+    end = total_lines if limit == 0 else min(total_lines, offset + limit)
+    sliced = all_lines[offset:end]
+    sliced_text = "\n".join(sliced)
+    if offset == 0 and limit == 0 and text.endswith("\n"):
+        sliced_text += "\n"
+
+    result: Dict[str, Any] = {
+        "path": _relative(target),
+        "content": sliced_text,
+        "total_lines": total_lines,
+        "start_line": offset + 1,
+        "end_line": end,
+    }
+    if line_numbers:
+        width = max(4, len(str(end or total_lines)))
+        result["numbered"] = "\n".join(
+            f"{(offset + i + 1):>{width}}\t{line}" for i, line in enumerate(sliced)
+        )
+    return result
 
 
 def write_file(path: str, content: str) -> Dict[str, Any]:
@@ -368,6 +400,199 @@ def write_file(path: str, content: str) -> Dict[str, Any]:
     return {"path": _relative(target), "bytes": target.stat().st_size}
 
 
+def edit_file(path: str, old_string: str, new_string: str, replace_all: bool = False) -> Dict[str, Any]:
+    """Precise diff-style edit: replace `old_string` with `new_string` in `path`.
+
+    Fails when `old_string` is missing or appears more than once (unless
+    replace_all=True). This forces the caller to read the file first and pass
+    enough surrounding context to uniquely identify the edit site — the same
+    discipline Claude Code uses for safe edits.
+    """
+    if old_string == new_string:
+        raise ToolError("old_string and new_string are identical; nothing to change.")
+    target = _resolve_path(path)
+    if not target.exists() or not target.is_file():
+        raise ToolError("File does not exist.")
+    if target.stat().st_size > MAX_FILE_BYTES:
+        raise ToolError("File is too large to edit.")
+
+    original = target.read_text(encoding="utf-8")
+    occurrences = original.count(old_string)
+    if occurrences == 0:
+        raise ToolError("old_string not found in file. Read the file first and copy the exact bytes (including whitespace).")
+    if occurrences > 1 and not replace_all:
+        raise ToolError(f"old_string is ambiguous: appears {occurrences} times. Add more context to make it unique, or pass replace_all=true.")
+
+    updated = original.replace(old_string, new_string) if replace_all else original.replace(old_string, new_string, 1)
+    if len(updated.encode("utf-8")) > MAX_FILE_BYTES:
+        raise ToolError("Resulting file would exceed the workspace size limit.")
+    target.write_text(updated, encoding="utf-8")
+
+    edited_line = original[: original.find(old_string)].count("\n") + 1
+    return {
+        "path": _relative(target),
+        "replacements": occurrences if replace_all else 1,
+        "bytes": target.stat().st_size,
+        "first_edit_line": edited_line,
+    }
+
+
+_GREP_BINARY_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".pdf", ".zip", ".tar",
+                    ".gz", ".bz2", ".xz", ".7z", ".mp3", ".mp4", ".mov", ".wav",
+                    ".woff", ".woff2", ".ttf", ".eot", ".ico", ".db", ".sqlite",
+                    ".pyc", ".pyo", ".o", ".so", ".dylib", ".dll", ".exe", ".bin"}
+_GREP_BINARY_DIRS = {"node_modules", ".git", ".venv", "venv", "__pycache__",
+                    ".pytest_cache", "dist", "build", ".next", ".cache"}
+
+
+def grep(
+    pattern: str,
+    path: str = ".",
+    glob: Optional[str] = None,
+    max_results: int = 50,
+    case_insensitive: bool = False,
+    context_lines: int = 0,
+) -> Dict[str, Any]:
+    """Regex search across the agent workspace.
+
+    Unlike `search_files` (single line, 9 extensions, substring only), this
+    walks all text files, supports regex, returns line numbers, and can
+    optionally include surrounding context lines. Skips obvious binary
+    files/directories.
+    """
+    if not pattern:
+        raise ToolError("Pattern is required.")
+    try:
+        flags = re.IGNORECASE if case_insensitive else 0
+        regex = re.compile(pattern, flags)
+    except re.error as exc:
+        raise ToolError(f"Invalid regex: {exc}") from exc
+
+    target = _resolve_path(path)
+    if not target.exists() or not target.is_dir():
+        raise ToolError("Path is not a directory.")
+
+    max_results = max(1, min(int(max_results), 500))
+    context_lines = max(0, min(int(context_lines), 8))
+    matches: List[Dict[str, Any]] = []
+    files_scanned = 0
+    files_with_matches = 0
+
+    iterator = target.rglob(glob) if glob else target.rglob("*")
+    for file_path in iterator:
+        if len(matches) >= max_results:
+            break
+        if not file_path.is_file():
+            continue
+        if file_path.suffix.lower() in _GREP_BINARY_EXTS:
+            continue
+        if any(part in _GREP_BINARY_DIRS for part in file_path.parts):
+            continue
+        if file_path.stat().st_size > MAX_FILE_BYTES:
+            continue
+        try:
+            lines = file_path.read_text(encoding="utf-8").splitlines()
+        except (UnicodeDecodeError, OSError):
+            continue
+
+        files_scanned += 1
+        file_had_match = False
+        for index, line in enumerate(lines, start=1):
+            if len(matches) >= max_results:
+                break
+            if not regex.search(line):
+                continue
+            file_had_match = True
+            entry: Dict[str, Any] = {
+                "path": _relative(file_path),
+                "line": index,
+                "match": line[:400],
+            }
+            if context_lines:
+                lo = max(0, index - 1 - context_lines)
+                hi = min(len(lines), index + context_lines)
+                entry["context"] = [
+                    {"line": lo + i + 1, "text": lines[lo + i][:200]}
+                    for i in range(hi - lo)
+                ]
+            matches.append(entry)
+        if file_had_match:
+            files_with_matches += 1
+
+    return {
+        "pattern": pattern,
+        "matches": matches,
+        "files_scanned": files_scanned,
+        "files_with_matches": files_with_matches,
+        "truncated": len(matches) >= max_results,
+    }
+
+
+_TODO_REL_PATH = ".lattice/todos.json"
+_TODO_ALLOWED_STATUS = {"pending", "in_progress", "completed"}
+
+
+def _todo_file() -> Path:
+    ensure_agent_root()
+    target = AGENT_ROOT / _TODO_REL_PATH
+    target.parent.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+def todo_read() -> Dict[str, Any]:
+    """Read the agent's persistent TODO list (per-workspace)."""
+    target = _todo_file()
+    if not target.exists():
+        return {"todos": [], "path": _TODO_REL_PATH}
+    try:
+        todos = json.loads(target.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        todos = []
+    if not isinstance(todos, list):
+        todos = []
+    return {"todos": todos, "path": _TODO_REL_PATH}
+
+
+def todo_write(todos: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Replace the agent's TODO list. Each todo: {id, content, status}.
+
+    Status must be one of: pending, in_progress, completed.
+    At most one todo should be in_progress at any time — the agent enforces
+    this convention; the tool only warns if violated.
+    """
+    if not isinstance(todos, list):
+        raise ToolError("todos must be a list.")
+    if len(todos) > 50:
+        raise ToolError("Too many todos (max 50). Split into smaller batches.")
+
+    cleaned: List[Dict[str, Any]] = []
+    in_progress_count = 0
+    for idx, raw in enumerate(todos, start=1):
+        if not isinstance(raw, dict):
+            raise ToolError(f"Todo #{idx} is not an object.")
+        content = str(raw.get("content") or "").strip()
+        if not content:
+            raise ToolError(f"Todo #{idx} is missing 'content'.")
+        status = str(raw.get("status") or "pending").strip().lower()
+        if status not in _TODO_ALLOWED_STATUS:
+            raise ToolError(f"Todo #{idx} has invalid status '{status}'. Use one of {sorted(_TODO_ALLOWED_STATUS)}.")
+        if status == "in_progress":
+            in_progress_count += 1
+        cleaned.append({
+            "id": str(raw.get("id") or idx),
+            "content": content[:240],
+            "status": status,
+        })
+
+    target = _todo_file()
+    target.write_text(json.dumps(cleaned, ensure_ascii=False, indent=2), encoding="utf-8")
+    return {
+        "todos": cleaned,
+        "path": _TODO_REL_PATH,
+        "warning": "More than one todo is in_progress; keep only one active at a time." if in_progress_count > 1 else None,
+    }
+
+
 def search_files(query: str, path: str = ".", max_results: int = 20) -> Dict[str, Any]:
     if not query:
         raise ToolError("Query is required.")
@@ -547,6 +772,12 @@ npm run dev
 npm run build
 npm run preview
 ```
+
+## Lattice AI Notes
+
+- Inspect `package.json` and existing config files before adding new libraries.
+- If you add Tailwind CSS, framer-motion, TypeScript, or other tooling, add the required config files too.
+- Do not report the app as complete until `npm run build` succeeds.
 """,
         "src/main.jsx": """import React from 'react'
 import ReactDOM from 'react-dom/client'
@@ -564,9 +795,13 @@ ReactDOM.createRoot(document.getElementById('root')).render(
 export default function App() {
   const [count, setCount] = useState(0)
   return (
-    <main style={{ maxWidth: 680, margin: '48px auto', fontFamily: 'system-ui, sans-serif' }}>
+    <main style={{ maxWidth: 760, margin: '48px auto', padding: '0 20px', fontFamily: 'system-ui, sans-serif' }}>
       <h1>Vite + React</h1>
       <p>Starter generated by Lattice AI agent.</p>
+      <p style={{ color: '#555', lineHeight: 1.6 }}>
+        Inspect the current setup before adding new UI libraries, then verify
+        changes with <code>npm run build</code>.
+      </p>
       <button onClick={() => setCount((c) => c + 1)}>count is {count}</button>
     </main>
   )
@@ -1206,11 +1441,36 @@ def execute_tool(action: str, args: Dict[str, Any]) -> Dict[str, Any]:
     if action == "workspace_tree":
         return workspace_tree(args.get("path", "."), args.get("max_depth", 3))
     if action == "read_file":
-        return read_file(args["path"])
+        return read_file(
+            args["path"],
+            offset=args.get("offset", 0),
+            limit=args.get("limit", 0),
+            line_numbers=args.get("line_numbers", True),
+        )
     if action == "write_file":
         return write_file(args["path"], args.get("content", ""))
+    if action == "edit_file":
+        return edit_file(
+            args["path"],
+            args["old_string"],
+            args["new_string"],
+            replace_all=bool(args.get("replace_all", False)),
+        )
+    if action == "grep":
+        return grep(
+            args["pattern"],
+            path=args.get("path", "."),
+            glob=args.get("glob"),
+            max_results=args.get("max_results", 50),
+            case_insensitive=bool(args.get("case_insensitive", False)),
+            context_lines=args.get("context_lines", 0),
+        )
     if action == "search_files":
         return search_files(args["query"], args.get("path", "."), args.get("max_results", 20))
+    if action == "todo_read":
+        return todo_read()
+    if action == "todo_write":
+        return todo_write(args.get("todos") or [])
     if action == "inspect_html":
         return inspect_html(args["path"])
     if action == "preview_url":