sylo-fieldbrain 0.1.0

package/scripts/fieldbrain_log_revisions.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""List revision history for a maintenance log entry (logicscout_log_revisions tool)."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.maintenance_log_service import list_log_revisions
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--entry-id", type=int, required=True)
+    parser.add_argument("--limit", type=int, default=20)
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    with Session(get_engine()) as session:
+        revisions = list_log_revisions(session, args.entry_id, limit=args.limit)
+
+    emit(
+        {
+            "ok": True,
+            "entry_id": args.entry_id,
+            "revisions": revisions,
+            "count": len(revisions),
+            "operator_chat": f"{len(revisions)} revision(s) for log entry {args.entry_id}.",
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_log_search.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Search maintenance log entries (logicscout_log_search tool)."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.maintenance_log_service import search_log_entries
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--query", default="", help="Full-text search (title, body, fault, tag)")
+    parser.add_argument("--project-id", type=int, default=None, help="Filter by project id")
+    parser.add_argument("--fault-code", default="", help="Filter by fault code (substring)")
+    parser.add_argument("--equipment-tag", default="", help="Filter by equipment tag (substring)")
+    parser.add_argument("--limit", type=int, default=25, help="Max results (default 25)")
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    with Session(get_engine()) as session:
+        entries = search_log_entries(
+            session,
+            query=args.query,
+            project_id=args.project_id,
+            fault_code=args.fault_code or None,
+            equipment_tag=args.equipment_tag or None,
+            limit=args.limit,
+        )
+
+    lines = []
+    for e in entries:
+        proj = f" [{e.get('project_name')}]" if e.get("project_name") else ""
+        fault = f" fault={e['fault_code']}" if e.get("fault_code") else ""
+        tag = f" tag={e['equipment_tag']}" if e.get("equipment_tag") else ""
+        lines.append(f"#{e['id']} {e['title']}{proj}{fault}{tag}")
+
+    emit(
+        {
+            "ok": True,
+            "count": len(entries),
+            "entries": entries,
+            "operator_chat": (
+                f"Found {len(entries)} log entr{'y' if len(entries) == 1 else 'ies'}.\n"
+                + ("\n".join(lines) if lines else "(none)")
+            ),
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_log_update.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Update a maintenance log entry with revision history (logicscout_log_update tool)."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.maintenance_log_service import update_log_entry
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--entry-id", type=int, required=True)
+    parser.add_argument("--title", default=None)
+    parser.add_argument("--body", default=None)
+    parser.add_argument("--fault-code", default=None)
+    parser.add_argument("--equipment-tag", default=None)
+    parser.add_argument("--logged-by", default=None)
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    try:
+        with Session(get_engine()) as session:
+            result = update_log_entry(
+                session,
+                args.entry_id,
+                title=args.title,
+                body=args.body,
+                fault_code=args.fault_code,
+                equipment_tag=args.equipment_tag,
+                logged_by=args.logged_by,
+            )
+    except ValueError as exc:
+        emit_error(str(exc))
+
+    emit(
+        {
+            "ok": True,
+            "entry": result,
+            "operator_chat": f"Updated maintenance log entry {args.entry_id} (previous version saved to revisions).",
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_project_create.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Create a LogicScout project (logicscout_project_create tool)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.brain_paths import ensure_project_brain_layout
+from services.project_service import create_project
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--name", required=True, help="12345 (job) or 12345-001 (sub-project)")
+    parser.add_argument("--org-id", default="default", help="Org id (default: default)")
+    parser.add_argument(
+        "--tags-json",
+        default="",
+        help='JSON array of tag strings, e.g. ["line3","packaging"]',
+    )
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    tags: list[str] | None = None
+    if args.tags_json.strip():
+        try:
+            parsed = json.loads(args.tags_json)
+            if isinstance(parsed, list):
+                tags = [str(x) for x in parsed]
+            else:
+                emit_error("--tags-json must be a JSON array")
+        except json.JSONDecodeError as exc:
+            emit_error(f"Invalid --tags-json: {exc}")
+
+    try:
+        with Session(get_engine()) as session:
+            project = create_project(
+                session,
+                name=args.name,
+                project_tags=tags,
+                org_id=args.org_id,
+            )
+        ensure_project_brain_layout(project["id"])
+        if project.get("parent_project_id"):
+            ensure_project_brain_layout(int(project["parent_project_id"]))
+    except ValueError as exc:
+        emit_error(str(exc))
+
+    level = project.get("level", "other")
+    if level == "sub_project":
+        chat = f"Created sub-project {project['id']}: {project['name']} (under project {project.get('job_number')})."
+    else:
+        chat = f"Created project {project['id']}: {project['name']}."
+
+    emit(
+        {
+            "ok": True,
+            "project": project,
+            "operator_chat": chat,
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_project_list.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""List LogicScout projects (logicscout_project_list tool)."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.project_service import list_projects, list_projects_with_stats
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--include-hidden", action="store_true", help="Include system-hidden projects")
+    parser.add_argument("--with-stats", action="store_true", help="Include brain/doc/log counts per project")
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    with Session(get_engine()) as session:
+        if args.with_stats:
+            projects = list_projects_with_stats(session, include_hidden=args.include_hidden)
+        else:
+            projects = list_projects(session, include_hidden=args.include_hidden)
+
+    lines = []
+    for p in projects:
+        if args.with_stats and p.get("stats"):
+            s = p["stats"]
+            lines.append(
+                f"{p['id']}: {p['name']} — {s.get('brain_entries', 0)} brain, "
+                f"{s.get('library_docs', 0)} docs, {s.get('maintenance_logs', 0)} logs"
+            )
+        else:
+            lines.append(f"{p['id']}: {p['name']}")
+    emit(
+        {
+            "ok": True,
+            "count": len(projects),
+            "projects": projects,
+            "operator_chat": (
+                f"Found {len(projects)} project(s).\n" + ("\n".join(lines) if lines else "(none)")
+            ),
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_search.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Hybrid search across project knowledge (logicscout_search tool)."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.search_service import hybrid_search
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--project-id",
+        type=int,
+        default=None,
+        help="Project to search (project + global). Omit for global-only search.",
+    )
+    parser.add_argument("--query", required=True, help="Search query text")
+    parser.add_argument("--limit", type=int, default=25, help="Max results (default 25)")
+    parser.add_argument(
+        "--source-type",
+        default="",
+        help="Optional filter: document, brain, tag, rung, etc.",
+    )
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    with Session(get_engine()) as session:
+        results = hybrid_search(
+            session,
+            args.project_id,
+            args.query,
+            limit=args.limit,
+            source_type=args.source_type or None,
+        )
+
+    lines = []
+    for r in results:
+        scope_tag = "global" if r.get("scope") == "global" else f"project {r.get('project_id')}"
+        lines.append(
+            f"[{r['score']}] ({scope_tag}) #{r['id']} {r['type']} {r['label']}: {r['snippet'][:160]}"
+        )
+
+    where = (
+        f"project {args.project_id} + global library/brain"
+        if args.project_id is not None
+        else "global library/brain only"
+    )
+    emit(
+        {
+            "ok": True,
+            "project_id": args.project_id,
+            "search_scope": "project_plus_global" if args.project_id is not None else "global_only",
+            "query": args.query,
+            "count": len(results),
+            "results": results,
+            "operator_chat": (
+                f"Search ({where}) for {args.query!r}: "
+                f"{len(results)} hit(s).\n"
+                + ("\n".join(lines) if lines else "(none)")
+            ),
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_ui_brain_list.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""List brain markdown files for FieldBrain dashboard."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.brain_service import list_brain_documents
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--scope",
+        choices=("global", "project"),
+        default="project",
+        help="global org brain or project brain",
+    )
+    parser.add_argument("--project-id", type=int, default=None, help="Required when scope=project")
+    parser.add_argument("--search", default="", help="Filter by path substring")
+    parser.add_argument("--limit", type=int, default=200)
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    if args.scope == "project" and args.project_id is None:
+        emit_error("--project-id is required when scope is project")
+
+    with Session(get_engine()) as session:
+        brains = list_brain_documents(
+            session,
+            scope=args.scope,
+            project_id=args.project_id,
+            search=args.search or None,
+            limit=args.limit,
+        )
+
+    lines = [f"#{b['id']} {b['relative_path']}" for b in brains]
+    emit(
+        {
+            "ok": True,
+            "scope": args.scope,
+            "project_id": args.project_id,
+            "count": len(brains),
+            "brains": brains,
+            "operator_chat": (
+                f"Listed {len(brains)} brain file(s) ({args.scope}).\n"
+                + ("\n".join(lines) if lines else "(none)")
+            ),
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_ui_project_create.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Create a project from FieldBrain dashboard (fieldbrain:projectCreate IPC)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.brain_paths import ensure_project_brain_layout
+from services.project_service import create_project_structured
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--job-number", default="", help="Five-digit project number (e.g. 12345)")
+    parser.add_argument(
+        "--sub-project-number",
+        default="",
+        help="Optional three-digit sub-project (e.g. 001) → creates 12345-001",
+    )
+    parser.add_argument("--name", default="", help="Legacy: full name 12345 or 12345-001")
+    parser.add_argument(
+        "--tags-json",
+        default="",
+        help='JSON array of tag strings, e.g. ["line3"]',
+    )
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    tags: list[str] | None = None
+    if args.tags_json.strip():
+        try:
+            parsed = json.loads(args.tags_json)
+            if isinstance(parsed, list):
+                tags = [str(x) for x in parsed]
+            else:
+                emit_error("--tags-json must be a JSON array")
+        except json.JSONDecodeError as exc:
+            emit_error(f"Invalid --tags-json: {exc}")
+
+    job_number = args.job_number.strip()
+    sub_number = args.sub_project_number.strip()
+    legacy_name = args.name.strip()
+
+    if legacy_name and not job_number:
+        from services.project_naming import parse_project_name
+
+        job, suffix = parse_project_name(legacy_name)
+        if not job:
+            emit_error("Provide --job-number (12345) or legacy --name in 12345 / 12345-001 format.")
+        job_number = job
+        sub_number = suffix or ""
+
+    if not job_number:
+        emit_error("Project number is required (five digits, e.g. 12345).")
+
+    try:
+        with Session(get_engine()) as session:
+            project = create_project_structured(
+                session,
+                job_number=job_number,
+                sub_project_number=sub_number or None,
+                project_tags=tags,
+            )
+        ensure_project_brain_layout(project["id"])
+        if project.get("parent_job_id"):
+            ensure_project_brain_layout(int(project["parent_job_id"]))
+    except ValueError as exc:
+        emit_error(str(exc))
+
+    if project["level"] == "sub_project":
+        chat = (
+            f"Created sub-project {project['id']}: {project['name']} "
+            f"(under project {project.get('job_number')})."
+        )
+    else:
+        chat = f"Created project {project['id']}: {project['name']}."
+
+    emit(
+        {
+            "ok": True,
+            "project": project,
+            "operator_chat": chat,
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/fieldbrain_ui_project_list.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""List projects with stats for FieldBrain dashboard (fieldbrain:projectList IPC)."""
+
+from __future__ import annotations
+
+import argparse
+
+from _db_lib import get_engine, verify_schema_version
+from _json_out import emit, emit_error
+from services.project_service import list_projects_with_stats
+from sqlalchemy.orm import Session
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--include-hidden", action="store_true", help="Include system-hidden projects")
+    args = parser.parse_args()
+
+    ok, msg = verify_schema_version()
+    if not ok:
+        emit_error(msg)
+
+    with Session(get_engine()) as session:
+        projects = list_projects_with_stats(session, include_hidden=args.include_hidden)
+
+    lines = []
+    for p in projects:
+        stats = p.get("stats") or {}
+        lines.append(
+            f"{p['id']}: {p['name']} — "
+            f"{stats.get('brain_entries', 0)} brain, "
+            f"{stats.get('library_docs', 0)} docs, "
+            f"{stats.get('maintenance_logs', 0)} logs"
+        )
+
+    emit(
+        {
+            "ok": True,
+            "count": len(projects),
+            "projects": projects,
+            "operator_chat": (
+                f"Found {len(projects)} project(s).\n" + ("\n".join(lines) if lines else "(none)")
+            ),
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()