loro-agent 0.1.0__py3-none-any.whl

loro/__init__.py

@@ -0,0 +1,5 @@
+"""Loro enterprise agent harness."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

loro/__main__.py

@@ -0,0 +1,4 @@
+from loro.cli import app
+
+if __name__ == "__main__":
+    app()

loro/artifacts/__init__.py

@@ -0,0 +1 @@
+"""Artifact generation modules for documents, presentations, spreadsheets, and briefs."""

loro/artifacts/briefs.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from loro.artifacts.common import ArtifactResult, ensure_output_dir, slugify, title_from_prompt
+
+
+@dataclass(frozen=True)
+class Brief:
+    title: str
+    summary: str
+    risks: list[str]
+    next_steps: list[str]
+
+
+def create_brief_artifact(
+    prompt: str,
+    output_dir: Path,
+    brief_type: str = "meeting",
+) -> ArtifactResult:
+    title = title_from_prompt(prompt, f"Loro {brief_type.title()} Brief")
+    slug = slugify(f"{brief_type}-{title}", "brief")
+    output_dir = ensure_output_dir(output_dir)
+    path = output_dir / f"{slug}.md"
+    brief = Brief(
+        title=title,
+        summary=prompt.strip(),
+        risks=[
+            "Source context may be incomplete.",
+            "Facts and metrics require human validation before distribution.",
+        ],
+        next_steps=[
+            "Confirm audience and decision needed.",
+            "Attach source documents or governed data references.",
+            "Assign owners for follow-up actions.",
+        ],
+    )
+    path.write_text(
+        f"# {brief.title}\n\n"
+        f"Type: {brief_type}\n\n"
+        "## Summary\n\n"
+        f"{brief.summary}\n\n"
+        "## Risks\n\n"
+        + "\n".join(f"- {risk}" for risk in brief.risks)
+        + "\n\n## Next Steps\n\n"
+        + "\n".join(f"- {step}" for step in brief.next_steps)
+        + "\n",
+        encoding="utf-8",
+    )
+    return ArtifactResult(
+        title=title,
+        kind=f"{brief_type}-brief",
+        paths=[path],
+        summary=f"Created {brief_type} brief artifact: {path}",
+    )

loro/artifacts/common.py

@@ -0,0 +1,54 @@
+import json
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from re import sub
+from typing import Any
+
+
+@dataclass(frozen=True)
+class ArtifactResult:
+    title: str
+    kind: str
+    paths: list[Path]
+    summary: str
+
+
+def slugify(value: str, fallback: str = "artifact") -> str:
+    normalized = sub(r"[^a-zA-Z0-9]+", "-", value.strip().lower()).strip("-")
+    return normalized or fallback
+
+
+def ensure_output_dir(output_dir: Path) -> Path:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    return output_dir
+
+
+def title_from_prompt(prompt: str, fallback: str) -> str:
+    cleaned = " ".join(prompt.strip().split())
+    if not cleaned:
+        return fallback
+    return cleaned[:80].rstrip(" .")
+
+
+def write_provenance(
+    *,
+    result: ArtifactResult,
+    prompt_preview: str,
+    assumptions: list[str] | None = None,
+) -> Path:
+    path = result.paths[0].with_suffix(result.paths[0].suffix + ".provenance.json")
+    payload: dict[str, Any] = {
+        "title": result.title,
+        "kind": result.kind,
+        "paths": [str(item) for item in result.paths],
+        "prompt_preview": prompt_preview,
+        "assumptions": assumptions or [
+            "Generated from user-approved prompt text.",
+            "No external governed data was queried by this artifact generator.",
+        ],
+        "created_at": datetime.now(UTC).isoformat(),
+        "generator": "loro.mvp.artifacts",
+    }
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    return path

loro/artifacts/documents.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from docx import Document
+
+from loro.artifacts.common import ArtifactResult, ensure_output_dir, slugify, title_from_prompt
+
+
+@dataclass(frozen=True)
+class DocumentDraft:
+    title: str
+    markdown: str
+
+
+def create_markdown_document(title: str, body: str) -> DocumentDraft:
+    return DocumentDraft(title=title, markdown=f"# {title}\n\n{body.strip()}\n")
+
+
+def create_document_artifact(prompt: str, output_dir: Path) -> ArtifactResult:
+    title = title_from_prompt(prompt, "Loro Document")
+    slug = slugify(title, "document")
+    output_dir = ensure_output_dir(output_dir)
+    markdown_path = output_dir / f"{slug}.md"
+    docx_path = output_dir / f"{slug}.docx"
+
+    body = (
+        "## Purpose\n\n"
+        f"{prompt.strip()}\n\n"
+        "## Draft\n\n"
+        "This document was generated by Loro's deterministic MVP artifact engine. "
+        "Future model integration will expand this draft with richer context, memory retrieval, "
+        "and governed enterprise data citations.\n\n"
+        "## Assumptions\n\n"
+        "- The user approved the prompt as source context.\n"
+        "- No restricted data was embedded by the scaffolded generator.\n\n"
+        "## Next Steps\n\n"
+        "- Review the draft for accuracy.\n"
+        "- Add organization-specific template requirements.\n"
+        "- Confirm whether any content should be promoted to local or shared memory.\n"
+    )
+    draft = create_markdown_document(title, body)
+    markdown_path.write_text(draft.markdown, encoding="utf-8")
+
+    document = Document()
+    document.add_heading(title, level=1)
+    for section in body.split("\n\n"):
+        if section.startswith("## "):
+            document.add_heading(section.removeprefix("## ").strip(), level=2)
+        elif section.strip():
+            document.add_paragraph(section.strip())
+    document.save(docx_path)
+
+    return ArtifactResult(
+        title=title,
+        kind="document",
+        paths=[markdown_path, docx_path],
+        summary=f"Created document artifacts: {markdown_path} and {docx_path}",
+    )

loro/artifacts/presentations.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from pptx import Presentation
+
+from loro.artifacts.common import ArtifactResult, ensure_output_dir, slugify, title_from_prompt
+
+
+@dataclass(frozen=True)
+class Slide:
+    title: str
+    bullets: list[str]
+
+
+@dataclass(frozen=True)
+class PresentationOutline:
+    title: str
+    slides: list[Slide]
+
+
+def create_presentation_artifact(prompt: str, output_dir: Path) -> ArtifactResult:
+    title = title_from_prompt(prompt, "Loro Presentation")
+    slug = slugify(title, "presentation")
+    output_dir = ensure_output_dir(output_dir)
+    outline_path = output_dir / f"{slug}-outline.md"
+    pptx_path = output_dir / f"{slug}.pptx"
+
+    outline = PresentationOutline(
+        title=title,
+        slides=[
+            Slide(
+                title="Context",
+                bullets=[prompt.strip(), "Audience and goals should be reviewed."],
+            ),
+            Slide(
+                title="Key Points",
+                bullets=[
+                    "Summarize the current state.",
+                    "Call out decisions, risks, and opportunities.",
+                    "Tie recommendations to enterprise memory and governed data when available.",
+                ],
+            ),
+            Slide(
+                title="Next Steps",
+                bullets=[
+                    "Validate facts and metrics.",
+                    "Apply organization template and branding.",
+                    "Confirm follow-up owners.",
+                ],
+            ),
+        ],
+    )
+    outline_sections = [f"# {outline.title}"]
+    outline_sections.extend(
+        f"## {slide.title}\n" + "\n".join(f"- {item}" for item in slide.bullets)
+        for slide in outline.slides
+    )
+    outline_path.write_text("\n\n".join(outline_sections) + "\n", encoding="utf-8")
+
+    deck = Presentation()
+    title_slide = deck.slides.add_slide(deck.slide_layouts[0])
+    title_slide.shapes.title.text = title
+    title_slide.placeholders[1].text = "Generated by Loro"
+    for slide in outline.slides:
+        ppt_slide = deck.slides.add_slide(deck.slide_layouts[1])
+        ppt_slide.shapes.title.text = slide.title
+        body = ppt_slide.shapes.placeholders[1].text_frame
+        body.clear()
+        for index, bullet in enumerate(slide.bullets):
+            paragraph = body.paragraphs[0] if index == 0 else body.add_paragraph()
+            paragraph.text = bullet
+            paragraph.level = 0
+    deck.save(pptx_path)
+
+    return ArtifactResult(
+        title=title,
+        kind="presentation",
+        paths=[outline_path, pptx_path],
+        summary=f"Created presentation artifacts: {outline_path} and {pptx_path}",
+    )

loro/artifacts/spreadsheets.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from openpyxl import Workbook, load_workbook
+from openpyxl.chart import BarChart, Reference
+
+from loro.artifacts.common import ArtifactResult, ensure_output_dir, slugify, title_from_prompt
+
+
+@dataclass(frozen=True)
+class WorkbookPlan:
+    title: str
+    sheets: list[str]
+    assumptions: list[str]
+
+
+def create_spreadsheet_artifact(prompt: str, output_dir: Path) -> ArtifactResult:
+    title = title_from_prompt(prompt, "Loro Workbook")
+    slug = slugify(title, "workbook")
+    output_dir = ensure_output_dir(output_dir)
+    xlsx_path = output_dir / f"{slug}.xlsx"
+    csv_path = output_dir / f"{slug}-summary.csv"
+
+    rows = [
+        ("Category", "Planned", "Actual", "Variance"),
+        ("Scope", 10, 8, "=C2-B2"),
+        ("Schedule", 10, 9, "=C3-B3"),
+        ("Risk", 10, 6, "=C4-B4"),
+    ]
+
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = "Summary"
+    sheet["A1"] = title
+    sheet["A2"] = "Prompt"
+    sheet["B2"] = prompt.strip()
+    start_row = 4
+    for row_index, row in enumerate(rows, start=start_row):
+        for column_index, value in enumerate(row, start=1):
+            sheet.cell(row=row_index, column=column_index, value=value)
+
+    chart = BarChart()
+    chart.title = "Planned vs Actual"
+    chart.y_axis.title = "Score"
+    chart.x_axis.title = "Category"
+    data = Reference(sheet, min_col=2, max_col=3, min_row=start_row, max_row=start_row + 3)
+    categories = Reference(sheet, min_col=1, min_row=start_row + 1, max_row=start_row + 3)
+    chart.add_data(data, titles_from_data=True)
+    chart.set_categories(categories)
+    sheet.add_chart(chart, "F4")
+    workbook.save(xlsx_path)
+
+    csv_path.write_text(
+        "\n".join(",".join(str(item) for item in row) for row in rows) + "\n",
+        encoding="utf-8",
+    )
+
+    # Validate the workbook can be opened after writing.
+    load_workbook(xlsx_path, data_only=False).close()
+
+    return ArtifactResult(
+        title=title,
+        kind="spreadsheet",
+        paths=[xlsx_path, csv_path],
+        summary=f"Created spreadsheet artifacts: {xlsx_path} and {csv_path}",
+    )

loro/audit.py

@@ -0,0 +1,42 @@
+import json
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from loro.config import AuditConfig
+
+
+@dataclass(frozen=True)
+class AuditEvent:
+    event_type: str
+    details: dict[str, Any] = field(default_factory=dict)
+    event_id: str = field(default_factory=lambda: str(uuid4()))
+    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+
+
+class AuditLogger:
+    def __init__(self, config: AuditConfig) -> None:
+        self.config = config
+        self.path = Path(config.path).expanduser()
+
+    def write(self, event_type: str, **details: Any) -> AuditEvent:
+        event = AuditEvent(event_type=event_type, details=details)
+        if not self.config.enabled:
+            return event
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "event_id": event.event_id,
+            "event_type": event.event_type,
+            "created_at": event.created_at.isoformat(),
+            "details": event.details,
+        }
+        with self.path.open("a", encoding="utf-8") as file:
+            file.write(json.dumps(payload, default=str) + "\n")
+        return event
+
+
+def prompt_preview(prompt: str, limit: int = 160) -> str:
+    normalized = " ".join(prompt.split())
+    return normalized[:limit]