noah-code 0.1.0__py3-none-any.whl

noah_code/sessions.py

@@ -0,0 +1,157 @@
+"""Session store: one SQLite DB per session via SQLiteStorageManager."""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from nooa.storage import SQLiteStorageManager
+
+from noah_code.workspace import Workspace
+
+
+class SessionError(RuntimeError):
+    """Session load/create failure."""
+
+
+@dataclass
+class SessionMeta:
+    session_id: str
+    workspace_path: str
+    workspace_identity: str
+    title: str = "untitled"
+    mode: str = "build"
+    model: str = "gpt-4o-mini"
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    permission_rules: list[dict] = field(default_factory=list)
+    journal: dict = field(default_factory=dict)
+    todos: dict = field(default_factory=dict)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2)
+
+    @classmethod
+    def from_json(cls, raw: str) -> SessionMeta:
+        return cls(**json.loads(raw))
+
+
+class SessionStore:
+    """Manage session directories and SQLite storage managers."""
+
+    def __init__(self, session_dir: Path) -> None:
+        self.session_dir = session_dir.expanduser().resolve()
+        self.session_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self.session_dir.chmod(0o700)
+
+    def _session_path(self, session_id: str) -> Path:
+        if re.fullmatch(r"[0-9a-f]{12}", session_id) is None:
+            raise SessionError(f"invalid session id: {session_id}")
+        path = (self.session_dir / session_id).resolve()
+        if path.parent != self.session_dir:
+            raise SessionError(f"session path escapes session directory: {session_id}")
+        return path
+
+    def _meta_path(self, session_id: str) -> Path:
+        return self._session_path(session_id) / "meta.json"
+
+    def _db_path(self, session_id: str) -> Path:
+        return self._session_path(session_id) / "session.db"
+
+    def create(self, workspace: Workspace, *, model: str, mode: str = "build") -> SessionMeta:
+        session_id = uuid.uuid4().hex[:12]
+        path = self._session_path(session_id)
+        path.mkdir(parents=True, exist_ok=False, mode=0o700)
+        meta = SessionMeta(
+            session_id=session_id,
+            workspace_path=str(workspace.root),
+            workspace_identity=workspace.identity,
+            model=model,
+            mode=mode,
+        )
+        self.save_meta(meta)
+        return meta
+
+    def save_meta(self, meta: SessionMeta) -> None:
+        meta.updated_at = time.time()
+        path = self._meta_path(meta.session_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(meta.to_json())
+        path.chmod(0o600)
+
+    def load_meta(self, session_id: str) -> SessionMeta:
+        path = self._meta_path(session_id)
+        if not path.is_file():
+            raise SessionError(f"session not found: {session_id}")
+        try:
+            meta = SessionMeta.from_json(path.read_text())
+        except (json.JSONDecodeError, TypeError, KeyError) as exc:
+            raise SessionError(
+                f"damaged session metadata for {session_id}: {exc}. "
+                f"Delete with: noah-code sessions delete {session_id}"
+            ) from exc
+        if meta.session_id != session_id:
+            raise SessionError(
+                f"damaged session metadata for {session_id}: embedded id is {meta.session_id!r}"
+            )
+        return meta
+
+    def open_storage(self, session_id: str) -> SQLiteStorageManager:
+        db = self._db_path(session_id)
+        db.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            storage = SQLiteStorageManager(db)
+            if db.exists():
+                db.chmod(0o600)
+            return storage
+        except Exception as exc:  # noqa: BLE001 - surface recovery path
+            raise SessionError(
+                f"cannot open session database {db}: {exc}. "
+                f"If damaged, delete with: noah-code sessions delete {session_id}"
+            ) from exc
+
+    def list_sessions(self, workspace: Workspace | None = None) -> list[SessionMeta]:
+        items: list[SessionMeta] = []
+        for child in sorted(
+            self.session_dir.iterdir(), key=lambda p: p.stat().st_mtime, reverse=True
+        ):
+            if not child.is_dir():
+                continue
+            meta_path = child / "meta.json"
+            if not meta_path.is_file():
+                continue
+            try:
+                meta = SessionMeta.from_json(meta_path.read_text())
+            except (json.JSONDecodeError, TypeError, KeyError):
+                continue
+            if (
+                meta.session_id != child.name
+                or re.fullmatch(r"[0-9a-f]{12}", meta.session_id) is None
+            ):
+                continue
+            if workspace and meta.workspace_identity != workspace.identity:
+                continue
+            items.append(meta)
+        return items
+
+    def latest_for_workspace(self, workspace: Workspace) -> SessionMeta | None:
+        sessions = self.list_sessions(workspace)
+        return sessions[0] if sessions else None
+
+    def delete(self, session_id: str) -> None:
+        import shutil
+
+        path = self._session_path(session_id)
+        if not path.exists():
+            raise SessionError(f"session not found: {session_id}")
+        shutil.rmtree(path)
+
+    def verify_workspace(self, meta: SessionMeta, workspace: Workspace) -> None:
+        if meta.workspace_identity != workspace.identity:
+            raise SessionError(
+                f"session {meta.session_id} belongs to {meta.workspace_path}, not {workspace.root}"
+            )

noah_code/skills_setup.py

@@ -0,0 +1,51 @@
+"""Skill discovery helpers for Noah Code."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from noah_code.config import NoahCodeConfig
+
+
+def skill_dirs(workspace: Path) -> list[Path]:
+    return [
+        Path.home() / ".config" / "noah-code" / "skills",
+        workspace / ".noah-code" / "skills",
+        workspace / "skills",
+    ]
+
+
+def install_skills(agent: Any, workspace: Path, config: NoahCodeConfig) -> str:
+    """Attach SkillRegistry, discover dirs, activate configured patterns.
+
+    Returns a short status string for diagnostics.
+    """
+    try:
+        from nooa.skill_registry import SkillRegistry
+    except ImportError:
+        return "SkillRegistry unavailable"
+
+    registry = SkillRegistry(agent)
+    agent.skills = registry
+    found: list[str] = []
+    existing = [d for d in skill_dirs(workspace) if d.is_dir()]
+    if existing:
+        registry.discover_skills_dirs(existing)
+        found = list(registry.discovered())
+
+    # Activation is opt-in from trusted user configuration. Repository config is
+    # not allowed to set enabled_skills (see config._USER_ONLY_CONFIG_KEYS).
+    patterns = list(config.enabled_skills)
+    try:
+        if patterns:
+            registry.activate(patterns)
+            approved = getattr(agent, "_sandbox_approved_roots", None)
+            if isinstance(approved, set):
+                for name in registry.activated():
+                    attr = registry._attr_map.get(name)  # noqa: SLF001 - registry has no public map
+                    if attr:
+                        approved.add(attr)
+    except Exception as exc:  # noqa: BLE001
+        return f"skills discovered={len(found)} activate_error={exc}"
+    return f"skills discovered={len(found)} activated={len(registry.activated())}"

noah_code/snapshots.py

@@ -0,0 +1,313 @@
+"""File mutation journal for safe undo/redo of WorkspaceTools edits."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import tempfile
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+@dataclass
+class FileMutation:
+    id: str
+    path: str
+    existed_before: bool
+    pre_hash: str | None
+    post_hash: str | None
+    pre_bytes: bytes | None
+    mode: int | None
+    turn_id: str
+    timestamp: float
+    post_bytes: bytes | None = None
+    post_mode: int | None = None
+
+
+@dataclass
+class TurnJournal:
+    turn_id: str
+    mutations: list[FileMutation] = field(default_factory=list)
+    shell_may_bypass: bool = False
+
+
+class SnapshotJournal:
+    """Journal WorkspaceTools mutations; refuse concurrent overwrites."""
+
+    def __init__(self, *, blob_limit: int = 2_000_000) -> None:
+        self.blob_limit = blob_limit
+        self._turns: list[TurnJournal] = []
+        self._redo: list[TurnJournal] = []
+        self._current: TurnJournal | None = None
+
+    def begin_turn(self) -> str:
+        turn_id = str(uuid.uuid4())
+        self._current = TurnJournal(turn_id=turn_id)
+        return turn_id
+
+    def end_turn(self) -> None:
+        if self._current and (self._current.mutations or self._current.shell_may_bypass):
+            self._turns.append(self._current)
+            self._redo.clear()
+        self._current = None
+
+    def mark_shell_bypass(self) -> None:
+        if self._current is not None:
+            self._current.shell_may_bypass = True
+
+    def record_preimage(self, path: Path) -> FileMutation:
+        existed = path.exists()
+        pre_bytes: bytes | None = None
+        pre_hash: str | None = None
+        mode: int | None = None
+        if existed:
+            data = path.read_bytes()
+            if len(data) <= self.blob_limit:
+                pre_bytes = data
+            pre_hash = _sha256(data)
+            mode = path.stat().st_mode
+        mut = FileMutation(
+            id=str(uuid.uuid4()),
+            path=str(path),
+            existed_before=existed,
+            pre_hash=pre_hash,
+            post_hash=None,
+            pre_bytes=pre_bytes,
+            mode=mode,
+            turn_id=self._current.turn_id if self._current else "none",
+            timestamp=time.time(),
+        )
+        if self._current is not None:
+            self._current.mutations.append(mut)
+        return mut
+
+    def record_postimage(self, mut: FileMutation, path: Path) -> None:
+        if path.exists():
+            data = path.read_bytes()
+            mut.post_hash = _sha256(data)
+            mut.post_bytes = data if len(data) <= self.blob_limit else None
+            mut.post_mode = path.stat().st_mode
+        else:
+            mut.post_hash = None
+            mut.post_bytes = None
+            mut.post_mode = None
+
+    def discard_mutation(self, mut: FileMutation) -> None:
+        """Forget a preimage when the corresponding edit failed."""
+        if self._current is not None:
+            self._current.mutations = [item for item in self._current.mutations if item is not mut]
+
+    def can_undo(self) -> bool:
+        return bool(self._turns)
+
+    def can_redo(self) -> bool:
+        return bool(self._redo)
+
+    def last_turn_reversible(self) -> bool:
+        if not self._turns:
+            return False
+        return not self._turns[-1].shell_may_bypass
+
+    def undo(self) -> TurnJournal:
+        if not self._turns:
+            raise RuntimeError("nothing to undo")
+        turn = self._turns[-1]
+        if turn.shell_may_bypass:
+            raise RuntimeError(
+                "this turn may include shell mutations outside the file journal; "
+                "full undo is not available"
+            )
+
+        # Preflight every mutation before touching the filesystem. For repeated
+        # edits to one path, simulate the intermediate hashes in reverse order.
+        simulated: dict[str, str | None] = {}
+        for mut in reversed(turn.mutations):
+            path = Path(mut.path)
+            actual = simulated.get(mut.path, self._path_hash(path))
+            if actual != mut.post_hash:
+                raise RuntimeError(
+                    f"refuse undo: {mut.path} changed since the edit (concurrent modification)"
+                )
+            if mut.existed_before:
+                if mut.pre_bytes is None:
+                    raise RuntimeError(f"cannot undo {mut.path}: preimage not stored (too large)")
+                if mut.pre_hash and _sha256(mut.pre_bytes) != mut.pre_hash:
+                    raise RuntimeError(f"corrupt preimage for {mut.path}")
+            if mut.post_hash is not None:
+                if mut.post_bytes is None:
+                    raise RuntimeError(f"cannot undo {mut.path}: postimage not stored (too large)")
+                if _sha256(mut.post_bytes) != mut.post_hash:
+                    raise RuntimeError(f"corrupt postimage for {mut.path}")
+            simulated[mut.path] = mut.pre_hash if mut.existed_before else None
+
+        applied: list[FileMutation] = []
+        try:
+            for mut in reversed(turn.mutations):
+                self._write_state(
+                    Path(mut.path),
+                    mut.pre_bytes if mut.existed_before else None,
+                    mut.mode,
+                )
+                applied.append(mut)
+        except Exception as exc:
+            for mut in reversed(applied):
+                self._write_state(Path(mut.path), mut.post_bytes, mut.post_mode)
+            raise RuntimeError(f"undo failed and was rolled back: {exc}") from exc
+
+        self._turns.pop()
+        self._redo.append(turn)
+        return turn
+
+    def redo(self) -> TurnJournal:
+        if not self._redo:
+            raise RuntimeError("nothing to redo")
+        turn = self._redo[-1]
+        simulated: dict[str, str | None] = {}
+        for mut in turn.mutations:
+            path = Path(mut.path)
+            expected = mut.pre_hash if mut.existed_before else None
+            actual = simulated.get(mut.path, self._path_hash(path))
+            if actual != expected:
+                raise RuntimeError(f"refuse redo: {mut.path} does not match undo state")
+            if mut.post_hash is not None:
+                if mut.post_bytes is None:
+                    raise RuntimeError(f"cannot redo {mut.path}: postimage not stored (too large)")
+                if _sha256(mut.post_bytes) != mut.post_hash:
+                    raise RuntimeError(f"corrupt postimage for {mut.path}")
+            simulated[mut.path] = mut.post_hash
+
+        applied: list[FileMutation] = []
+        try:
+            for mut in turn.mutations:
+                self._write_state(Path(mut.path), mut.post_bytes, mut.post_mode)
+                applied.append(mut)
+        except Exception as exc:
+            for mut in reversed(applied):
+                self._write_state(
+                    Path(mut.path),
+                    mut.pre_bytes if mut.existed_before else None,
+                    mut.mode,
+                )
+            raise RuntimeError(f"redo failed and was rolled back: {exc}") from exc
+
+        self._redo.pop()
+        self._turns.append(turn)
+        return turn
+
+    def capture_post_bytes_before_undo(self, turn: TurnJournal) -> None:
+        # Backward compatibility for journals written before postimages were
+        # persisted. Only the latest mutation for each path can be reconstructed
+        # from the current filesystem state.
+        seen: set[str] = set()
+        for mut in reversed(turn.mutations):
+            if mut.path in seen:
+                continue
+            seen.add(mut.path)
+            path = Path(mut.path)
+            if mut.post_bytes is None and path.exists() and path.stat().st_size <= self.blob_limit:
+                mut.post_bytes = path.read_bytes()
+                mut.post_mode = path.stat().st_mode
+
+    @staticmethod
+    def _path_hash(path: Path) -> str | None:
+        return _sha256(path.read_bytes()) if path.exists() else None
+
+    @staticmethod
+    def _write_state(path: Path, data: bytes | None, mode: int | None) -> None:
+        if data is None:
+            if path.exists():
+                path.unlink()
+            return
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, temp_name = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+        try:
+            with os.fdopen(fd, "wb") as fh:
+                fh.write(data)
+                fh.flush()
+                os.fsync(fh.fileno())
+            if mode is not None:
+                Path(temp_name).chmod(mode)
+            os.replace(temp_name, path)
+        finally:
+            with __import__("contextlib").suppress(FileNotFoundError):
+                Path(temp_name).unlink()
+
+    def to_dict(self) -> dict:
+        return {
+            "turns": [self._turn_to_dict(t) for t in self._turns],
+            "redo": [self._turn_to_dict(t) for t in self._redo],
+        }
+
+    def load_dict(self, data: dict | None) -> None:
+        if not data:
+            self._turns = []
+            self._redo = []
+            return
+        self._turns = [self._turn_from_dict(t) for t in data.get("turns", [])]
+        self._redo = [self._turn_from_dict(t) for t in data.get("redo", [])]
+
+    @staticmethod
+    def _turn_to_dict(turn: TurnJournal) -> dict:
+        return {
+            "turn_id": turn.turn_id,
+            "shell_may_bypass": turn.shell_may_bypass,
+            "mutations": [
+                {
+                    "id": m.id,
+                    "path": m.path,
+                    "existed_before": m.existed_before,
+                    "pre_hash": m.pre_hash,
+                    "post_hash": m.post_hash,
+                    "pre_bytes_b64": (
+                        __import__("base64").b64encode(m.pre_bytes).decode()
+                        if m.pre_bytes is not None
+                        else None
+                    ),
+                    "post_bytes_b64": (
+                        __import__("base64").b64encode(m.post_bytes).decode()
+                        if m.post_bytes is not None
+                        else None
+                    ),
+                    "mode": m.mode,
+                    "post_mode": m.post_mode,
+                    "turn_id": m.turn_id,
+                    "timestamp": m.timestamp,
+                }
+                for m in turn.mutations
+            ],
+        }
+
+    @staticmethod
+    def _turn_from_dict(data: dict) -> TurnJournal:
+        import base64
+
+        muts = []
+        for m in data.get("mutations", []):
+            pre = m.get("pre_bytes_b64")
+            post = m.get("post_bytes_b64")
+            muts.append(
+                FileMutation(
+                    id=m["id"],
+                    path=m["path"],
+                    existed_before=m["existed_before"],
+                    pre_hash=m.get("pre_hash"),
+                    post_hash=m.get("post_hash"),
+                    pre_bytes=base64.b64decode(pre) if pre else None,
+                    mode=m.get("mode"),
+                    turn_id=m["turn_id"],
+                    timestamp=m.get("timestamp", 0.0),
+                    post_bytes=base64.b64decode(post) if post else None,
+                    post_mode=m.get("post_mode"),
+                )
+            )
+        return TurnJournal(
+            turn_id=data["turn_id"],
+            mutations=muts,
+            shell_may_bypass=bool(data.get("shell_may_bypass")),
+        )

noah_code/tools/__init__.py

@@ -0,0 +1,6 @@
+"""Re-export workspace and git tools."""
+
+from noah_code.tools.git_tools import GitTools
+from noah_code.tools.workspace_tools import WorkspaceTools
+
+__all__ = ["GitTools", "WorkspaceTools"]

noah_code/tools/git_tools.py

@@ -0,0 +1,44 @@
+"""Narrow git helpers - status/diff/log only by default."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from nooa import Skill, spec
+
+from noah_code.tools.workspace_tools import WorkspaceTools
+
+
+class GitTools(Skill):
+    """Read-oriented git helpers. Mutating git still goes through workspace.run with policy."""
+
+    def __init__(self, workspace_tools: WorkspaceTools) -> None:
+        super().__init__()
+        self._ws = workspace_tools
+
+    async def status(self) -> str:
+        """Return ``git status --short --branch`` output."""
+        result = await self._ws.run_trusted_readonly("git status --short --branch")
+        return result.stdout or result.stderr
+
+    async def diff(
+        self,
+        path: Annotated[str | None, spec(description="Optional path limit")] = None,
+    ) -> str:
+        """Return ``git diff`` (unstaged + staged summary via --stat if no path)."""
+        if path:
+            import shlex
+
+            cmd = f"git diff -- {shlex.quote(path)}"
+        else:
+            cmd = "git diff"
+        result = await self._ws.run_trusted_readonly(cmd)
+        return result.stdout or "(no diff)"
+
+    async def log(
+        self,
+        n: Annotated[int, spec(description="Number of commits")] = 5,
+    ) -> str:
+        """Return recent commit subjects."""
+        result = await self._ws.run_trusted_readonly(f"git log -n {int(n)} --oneline")
+        return result.stdout or "(no commits)"