sylo-fieldbrain 0.1.0

package/scripts/pgvector_install_from_folder.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Copy pgvector from operator folder/zip, then enable extension in FieldBrain DB."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from _db_lib import load_database_config, run_health_check
+from _json_out import emit, emit_error
+from services.pgvector_windows import (
+    guess_pgroot_for_major,
+    install_pgvector_files,
+    layman_pgvector_steps,
+    resolve_source_dir,
+    windows_install_status,
+)
+
+
+def _parse_script_json(stdout: str) -> dict:
+    trimmed = stdout.strip()
+    if not trimmed:
+        return {"ok": False, "error": "empty output"}
+    for line in reversed(trimmed.splitlines()):
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            return json.loads(line)
+        except json.JSONDecodeError:
+            continue
+    return {"ok": False, "error": trimmed}
+
+
+def _run_enable(args: argparse.Namespace, admin_password: str) -> dict:
+    script = Path(__file__).resolve().parent / "pgvector_enable.py"
+    cmd = [
+        sys.executable,
+        str(script),
+        "--admin-user",
+        args.admin_user,
+        "--admin-password",
+        admin_password,
+        "--host",
+        args.host,
+        "--port",
+        str(args.port),
+        "--database",
+        args.database,
+    ]
+    proc = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    parsed = _parse_script_json(proc.stdout or "")
+    if parsed.get("ok") is False and proc.stderr:
+        parsed.setdefault("error", proc.stderr.strip())
+    return parsed
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", default="", help="Folder or .zip with pgvector files (local Postgres only)")
+    parser.add_argument("--admin-user", default="postgres")
+    parser.add_argument("--admin-password", default="")
+    parser.add_argument("--host", default="")
+    parser.add_argument("--port", type=int, default=0)
+    parser.add_argument("--database", default="")
+    parser.add_argument("--skip-file-copy", action="store_true", help="Only CREATE EXTENSION (remote server)")
+    args = parser.parse_args()
+
+    admin_password = (args.admin_password or os.environ.get("SYLO_FIELDBRAIN_BOOTSTRAP_ADMIN_PASSWORD") or "").strip()
+    if not admin_password:
+        emit_error("Postgres superuser password is required (not saved).")
+
+    cfg = load_database_config() or {}
+    host = (args.host or str(cfg.get("host") or "localhost")).strip()
+    port = args.port or int(cfg.get("port") or 5432)
+    database = (args.database or str(cfg.get("database") or "fieldbrain")).strip()
+    args.host = host
+    args.port = port
+    args.database = database
+
+    health = run_health_check()
+    if health.get("postgres_connected") is not True:
+        emit_error(health.get("postgres_error", "Connect to Postgres first (Test connection)."))
+
+    major = health.get("postgres_major")
+    if isinstance(major, str) and major.isdigit():
+        major = int(major)
+    install = windows_install_status(major if isinstance(major, int) else None)
+    db_mode = "remote" if host not in ("localhost", "127.0.0.1") else str(
+        health.get("db_mode") or "local"
+    )
+
+    copy_steps: list[str] = []
+    if not args.skip_file_copy and db_mode == "local":
+        source = (args.source or "").strip()
+        if not source:
+            emit_error(
+                "Select the extracted pgvector folder (or .zip) first.",
+                pgvector_setup=layman_pgvector_steps(
+                    major if isinstance(major, int) else None,
+                    files_installed=bool(install.get("vector_files_installed")),
+                    db_mode=db_mode,
+                ),
+            )
+        pgroot = guess_pgroot_for_major(major) if isinstance(major, int) else None
+        if pgroot is None:
+            emit_error("Could not find PostgreSQL install folder on this PC.")
+        source_dir, tmp, err = resolve_source_dir(source)
+        if err or source_dir is None:
+            emit_error(err or "Invalid pgvector source path")
+        try:
+            copy_result = install_pgvector_files(source_dir, pgroot)
+        finally:
+            if tmp is not None:
+                tmp.cleanup()
+        if not copy_result.get("ok"):
+            emit_error(
+                copy_result.get("error", "File copy failed"),
+                **{
+                    **install,
+                    "needs_elevation": copy_result.get("needs_elevation"),
+                    "pgroot": copy_result.get("pgroot") or install.get("pgroot"),
+                    "source_dir": str(source_dir),
+                },
+            )
+        copy_steps.append(f"Installed pgvector files into {copy_result.get('pgroot')}")
+        install = windows_install_status(major if isinstance(major, int) else None)
+
+    enable_result = _run_enable(args, admin_password)
+    if enable_result.get("ok") is False:
+        emit_error(
+            enable_result.get("error", "Enable failed"),
+            pgvector_setup=enable_result.get("pgvector_setup"),
+            **install,
+        )
+
+    lines = [*copy_steps]
+    if enable_result.get("operator_chat"):
+        lines.append(str(enable_result["operator_chat"]))
+    emit({**enable_result, "operator_chat": "\n".join(lines), **install})
+
+
+if __name__ == "__main__":
+    main()

package/scripts/postbuild-ui.mjs

@@ -0,0 +1,13 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const dest = path.join(root, 'skills/fieldbrain/routes/fieldbrain/fallback.md')
+const src = path.join(root, 'ui/fallback.md')
+
+if (fs.existsSync(src)) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true })
+  fs.copyFileSync(src, dest)
+  console.log('[sylo-fieldbrain] copied ui/fallback.md →', dest)
+}

package/scripts/requirements.txt

@@ -0,0 +1,7 @@
+sqlalchemy>=2.0.0
+psycopg2-binary>=2.9.9
+alembic>=1.13.0
+python-dotenv>=1.0.0
+httpx>=0.27.0
+pymupdf>=1.24.0
+pgvector>=0.3.0

package/scripts/services/__init__.py

@@ -0,0 +1 @@
+"""LogicScout service modules."""

package/scripts/services/brain_paths.py

@@ -0,0 +1,81 @@
+"""Brain filesystem path helpers (stub — full write/index in later phases)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from _db_lib import package_root
+
+GLOBAL_BRAIN_PROJECT_NAME = "__fieldbrain_global_brain__"
+
+_BRAIN_SUBDIRS = (
+    "inbox",
+    "issues",
+    "gotchas",
+    "runbooks",
+    "decisions",
+    "common_issues",
+    "attachments",
+)
+
+
+def storage_root() -> Path:
+    """Shared on-disk storage under the package (server-side or local Postgres host)."""
+    root = package_root() / "shared" / "storage"
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def project_brain_root(project_id: int) -> Path:
+    return storage_root() / str(project_id) / "brain"
+
+
+def global_brain_root() -> Path:
+    return storage_root() / "global" / "brain"
+
+
+def ensure_project_brain_layout(project_id: int) -> Path:
+    """Create brain/ subdirs if missing. Does not seed INDEX.md yet (Phase 4+)."""
+    root = project_brain_root(project_id)
+    root.mkdir(parents=True, exist_ok=True)
+    for sub in _BRAIN_SUBDIRS:
+        (root / sub).mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def ensure_global_brain_layout() -> Path:
+    root = global_brain_root()
+    root.mkdir(parents=True, exist_ok=True)
+    for sub in (*_BRAIN_SUBDIRS, "references"):
+        (root / sub).mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def safe_relative_brain_path(spec: str) -> str | None:
+    if not spec or not spec.strip():
+        return None
+    raw = spec.strip().strip("`").replace("\\", "/")
+    parts = Path(raw).parts
+    if any(p == ".." or p.startswith("..") for p in parts):
+        return None
+    if parts and parts[0] == "brain":
+        parts = parts[1:]
+    if not parts:
+        return None
+    rel = "/".join(parts)
+    if ".." in rel.split("/"):
+        return None
+    if not rel.endswith(".md"):
+        return None
+    return rel
+
+
+def resolve_brain_path(brain_root: Path, relative: str) -> Path | None:
+    rel = safe_relative_brain_path(relative)
+    if not rel:
+        return None
+    target = (brain_root / rel).resolve()
+    root_resolved = brain_root.resolve()
+    if root_resolved not in target.parents and target != root_resolved:
+        return None
+    return target

package/scripts/services/brain_service.py

@@ -0,0 +1,280 @@
+"""Read/write brain markdown in Postgres with revisions and soft delete."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from models import BrainDocument, BrainDocumentRevision
+from services.brain_paths import safe_relative_brain_path
+from services.global_brain_support import ensure_global_brain_shell_project
+
+
+def _scope_norm(scope: str) -> str:
+    s = (scope or "project").strip().lower()
+    if s not in ("global", "project"):
+        raise ValueError("scope must be global or project")
+    return s
+
+
+def _resolve_scope_project(session: Session, scope: str, project_id: int | None) -> tuple[str, int | None]:
+    scope_n = _scope_norm(scope)
+    if scope_n == "global":
+        ensure_global_brain_shell_project(session)
+        return scope_n, None
+    if project_id is None:
+        raise ValueError("project_id is required when scope is project")
+    return scope_n, project_id
+
+
+def _active_brain_query(session: Session, scope: str, project_id: int | None, relative_path: str):
+    scope_n, pid = _resolve_scope_project(session, scope, project_id)
+    q = session.query(BrainDocument).filter(
+        BrainDocument.scope == scope_n,
+        BrainDocument.relative_path == relative_path,
+        BrainDocument.deleted_at.is_(None),
+    )
+    if scope_n == "global":
+        q = q.filter(BrainDocument.project_id.is_(None))
+    else:
+        q = q.filter(BrainDocument.project_id == pid)
+    return q
+
+
+def _next_brain_revision(session: Session, doc_id: int) -> int:
+    current = (
+        session.query(func.max(BrainDocumentRevision.revision_number))
+        .filter(BrainDocumentRevision.brain_document_id == doc_id)
+        .scalar()
+    )
+    return int(current or 0) + 1
+
+
+def _save_brain_revision(session: Session, doc: BrainDocument) -> None:
+    rev = BrainDocumentRevision(
+        brain_document_id=doc.id,
+        relative_path=doc.relative_path,
+        content=doc.content,
+        revision_number=_next_brain_revision(session, doc.id),
+    )
+    session.add(rev)
+
+
+def brain_doc_to_dict(doc: BrainDocument) -> dict[str, Any]:
+    return {
+        "id": doc.id,
+        "scope": doc.scope,
+        "project_id": doc.project_id,
+        "relative_path": doc.relative_path,
+        "content": doc.content,
+        "size_bytes": len((doc.content or "").encode("utf-8")),
+        "deleted_at": doc.deleted_at.isoformat() if doc.deleted_at else None,
+        "created_at": doc.created_at.isoformat() if doc.created_at else None,
+        "updated_at": doc.updated_at.isoformat() if doc.updated_at else None,
+    }
+
+
+def brain_doc_list_item(doc: BrainDocument) -> dict[str, Any]:
+    return {
+        "id": doc.id,
+        "scope": doc.scope,
+        "project_id": doc.project_id,
+        "relative_path": doc.relative_path,
+        "size_bytes": len((doc.content or "").encode("utf-8")),
+        "updated_at": doc.updated_at.isoformat() if doc.updated_at else None,
+    }
+
+
+def list_brain_documents(
+    session: Session,
+    *,
+    scope: str = "project",
+    project_id: int | None = None,
+    search: str | None = None,
+    limit: int = 200,
+) -> list[dict[str, Any]]:
+    scope_n = _scope_norm(scope)
+    query = session.query(BrainDocument).filter(BrainDocument.deleted_at.is_(None))
+    if scope_n == "global":
+        query = query.filter(BrainDocument.scope == "global", BrainDocument.project_id.is_(None))
+    else:
+        if project_id is None:
+            raise ValueError("project_id is required when scope is project")
+        query = query.filter(BrainDocument.scope == "project", BrainDocument.project_id == project_id)
+
+    term = (search or "").strip()
+    if term:
+        like = f"%{term}%"
+        query = query.filter(BrainDocument.relative_path.ilike(like))
+
+    cap = max(1, min(int(limit), 500))
+    rows = query.order_by(BrainDocument.relative_path.asc()).limit(cap).all()
+    return [brain_doc_list_item(d) for d in rows]
+
+
+def read_brain_markdown(
+    session: Session,
+    *,
+    scope: str,
+    relative_path: str,
+    project_id: int | None = None,
+) -> dict[str, Any]:
+    rel = safe_relative_brain_path(relative_path)
+    if not rel:
+        raise ValueError("Invalid brain path (must be a .md file under brain/, no .. segments)")
+
+    doc = _active_brain_query(session, scope, project_id, rel).first()
+    if not doc:
+        raise ValueError(f"Brain file not found: {rel}")
+
+    result = brain_doc_to_dict(doc)
+    result["storage"] = "postgres"
+    return result
+
+
+def write_brain_markdown(
+    session: Session,
+    *,
+    scope: str,
+    relative_path: str,
+    content: str,
+    project_id: int | None = None,
+    mode: str = "replace",
+) -> dict[str, Any]:
+    rel = safe_relative_brain_path(relative_path)
+    if not rel:
+        raise ValueError("Invalid brain path (must be a .md file under brain/, no .. segments)")
+
+    scope_n, pid = _resolve_scope_project(session, scope, project_id)
+    mode_norm = (mode or "replace").strip().lower()
+    if mode_norm not in ("replace", "append"):
+        raise ValueError("mode must be replace or append")
+
+    doc = _active_brain_query(session, scope, project_id, rel).first()
+    created = doc is None
+
+    if doc is None:
+        doc = BrainDocument(scope=scope_n, project_id=pid, relative_path=rel, content="")
+        session.add(doc)
+        session.flush()
+
+    if mode_norm == "append" and doc.content:
+        new_content = doc.content.rstrip() + "\n\n" + (content or "")
+    else:
+        new_content = content or ""
+
+    if not created and doc.content != new_content:
+        _save_brain_revision(session, doc)
+
+    doc.content = new_content
+    doc.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
+    session.commit()
+    session.refresh(doc)
+
+    result = brain_doc_to_dict(doc)
+    result["storage"] = "postgres"
+    result["mode"] = mode_norm
+    result["created"] = created
+    return result
+
+
+def soft_delete_brain(
+    session: Session,
+    *,
+    scope: str,
+    relative_path: str,
+    project_id: int | None = None,
+) -> dict[str, Any]:
+    rel = safe_relative_brain_path(relative_path)
+    if not rel:
+        raise ValueError("Invalid brain path")
+
+    doc = _active_brain_query(session, scope, project_id, rel).first()
+    if not doc:
+        raise ValueError(f"Brain file not found: {rel}")
+
+    _save_brain_revision(session, doc)
+    doc.deleted_at = datetime.now(timezone.utc).replace(tzinfo=None)
+    session.commit()
+    return {"ok": True, "id": doc.id, "relative_path": rel, "soft_deleted": True}
+
+
+def restore_brain(
+    session: Session,
+    *,
+    scope: str,
+    relative_path: str,
+    project_id: int | None = None,
+) -> dict[str, Any]:
+    rel = safe_relative_brain_path(relative_path)
+    if not rel:
+        raise ValueError("Invalid brain path")
+
+    scope_n, pid = _resolve_scope_project(session, scope, project_id)
+    q = session.query(BrainDocument).filter(
+        BrainDocument.scope == scope_n,
+        BrainDocument.relative_path == rel,
+        BrainDocument.deleted_at.isnot(None),
+    )
+    if scope_n == "global":
+        q = q.filter(BrainDocument.project_id.is_(None))
+    else:
+        q = q.filter(BrainDocument.project_id == pid)
+
+    doc = q.order_by(BrainDocument.deleted_at.desc()).first()
+    if not doc:
+        raise ValueError(f"No deleted brain file to restore: {rel}")
+
+    conflict = _active_brain_query(session, scope, project_id, rel).first()
+    if conflict:
+        raise ValueError(f"An active brain file already exists at {rel}; delete or rename it first")
+
+    doc.deleted_at = None
+    session.commit()
+    return brain_doc_to_dict(doc)
+
+
+def list_brain_revisions(
+    session: Session,
+    *,
+    scope: str,
+    relative_path: str,
+    project_id: int | None = None,
+    limit: int = 20,
+) -> list[dict[str, Any]]:
+    rel = safe_relative_brain_path(relative_path)
+    if not rel:
+        raise ValueError("Invalid brain path")
+
+    doc = _active_brain_query(session, scope, project_id, rel).first()
+    if not doc:
+        doc = (
+            session.query(BrainDocument)
+            .filter(BrainDocument.relative_path == rel)
+            .order_by(BrainDocument.updated_at.desc())
+            .first()
+        )
+    if not doc:
+        return []
+
+    cap = max(1, min(int(limit), 100))
+    rows = (
+        session.query(BrainDocumentRevision)
+        .filter(BrainDocumentRevision.brain_document_id == doc.id)
+        .order_by(BrainDocumentRevision.revision_number.desc())
+        .limit(cap)
+        .all()
+    )
+    return [
+        {
+            "revision_number": r.revision_number,
+            "relative_path": r.relative_path,
+            "content_preview": (r.content[:400] + "…") if len(r.content) > 400 else r.content,
+            "content_length": len(r.content),
+            "created_at": r.created_at.isoformat() if r.created_at else None,
+        }
+        for r in rows
+    ]