@1mancompany/onemancompany 0.7.27 → 0.7.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mancompany/onemancompany",
-  "version": "0.7.27",
+  "version": "0.7.31",
   "description": "The AI Operating System for One-Person Companies",
   "bin": {
     "onemancompany": "bin/cli.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onemancompany"
-version = "0.7.27"
+version = "0.7.31"
 description = "A one-man company simulation with pixel art visualization and LangChain AI agents"
 requires-python = ">=3.12"
 dependencies = [

package/src/onemancompany/agents/product_tools.py

@@ -562,6 +562,135 @@ async def manage_review_tool(
         return f"Error: {e}"
 
 
+# ---------------------------------------------------------------------------
+# B2: Missing CRUD + analytics tools
+# ---------------------------------------------------------------------------
+
+
+@tool
+def delete_issue_tool(product_slug: str, issue_id: str) -> str:
+    """Delete an issue and clean up all links referencing it.
+
+    Args:
+        product_slug: The product slug
+        issue_id: The issue ID to delete
+    """
+    try:
+        prod.delete_issue(product_slug, issue_id)
+        return f"Deleted issue {issue_id} from {product_slug}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def reopen_issue_tool(product_slug: str, issue_id: str) -> str:
+    """Reopen a closed issue (moves it back to backlog).
+
+    Args:
+        product_slug: The product slug
+        issue_id: The issue ID to reopen
+    """
+    try:
+        issue = prod.reopen_issue(product_slug, issue_id)
+        return f"Reopened issue {issue_id}: status={issue['status']}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def start_sprint_tool(product_slug: str, sprint_id: str) -> str:
+    """Start a sprint (set it to active). Only one sprint can be active at a time.
+
+    Args:
+        product_slug: The product slug
+        sprint_id: The sprint ID to start
+    """
+    try:
+        sprint = prod.start_sprint(product_slug, sprint_id)
+        return f"Started sprint {sprint_id}: {sprint['name']}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def delete_sprint_tool(product_slug: str, sprint_id: str) -> str:
+    """Delete a sprint. Cannot delete an active sprint — close it first.
+
+    Args:
+        product_slug: The product slug
+        sprint_id: The sprint ID to delete
+    """
+    try:
+        prod.delete_sprint(product_slug, sprint_id)
+        return f"Deleted sprint {sprint_id} from {product_slug}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def sprint_analytics_tool(product_slug: str, sprint_id: str) -> str:
+    """Get sprint analytics: velocity (story points completed).
+
+    Args:
+        product_slug: The product slug
+        sprint_id: The sprint ID
+    """
+    try:
+        sprint = prod.load_sprint(product_slug, sprint_id)
+        if not sprint:
+            return f"Error: Sprint '{sprint_id}' not found"
+        velocity = prod.get_sprint_velocity(product_slug, sprint_id)
+        issues = prod.list_issues(product_slug, sprint=sprint_id)
+        done = sum(1 for i in issues if i.get("status") in ("done", "released"))
+        total = len(issues)
+        lines = [
+            f"Sprint: {sprint['name']} ({sprint['status']})",
+            f"Velocity: {velocity} story points",
+            f"Issues: {done}/{total} done",
+            f"Dates: {sprint['start_date']} → {sprint['end_date']}",
+        ]
+        if sprint.get("goal"):
+            lines.append(f"Goal: {sprint['goal']}")
+        return "\n".join(lines)
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def version_management_tool(
+    product_slug: str,
+    action: str,
+    resolved_issue_ids: str = "",
+    bump: str = "patch",
+) -> str:
+    """Manage product versions. Actions: list, release.
+
+    Args:
+        product_slug: The product slug
+        action: 'list' to list versions, 'release' to release a new version
+        resolved_issue_ids: Comma-separated issue IDs resolved in this release (for 'release')
+        bump: Version bump type: 'patch', 'minor', or 'major' (default: 'patch')
+    """
+    try:
+        if action == "list":
+            versions = prod.list_versions(product_slug)
+            if not versions:
+                return f"No versions released for {product_slug}"
+            lines = [f"Versions for {product_slug}:"]
+            for v in versions:
+                lines.append(f"  {v['version']} — released {v.get('released_at', '?')}")
+            return "\n".join(lines)
+
+        if action == "release":
+            ids = [i.strip() for i in resolved_issue_ids.split(",") if i.strip()]
+            version = prod.release_version(product_slug, ids, bump=bump)
+            return f"Released v{version['version']} with {len(ids)} resolved issues"
+
+        return f"Error: unknown action '{action}'. Use: list, release"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
 # ---------------------------------------------------------------------------
 # Export
 # ---------------------------------------------------------------------------
@@ -581,4 +710,10 @@ PRODUCT_TOOLS = [
     unlink_issues_tool,
     check_blocked_issues_tool,
     manage_review_tool,
+    delete_issue_tool,
+    reopen_issue_tool,
+    start_sprint_tool,
+    delete_sprint_tool,
+    sprint_analytics_tool,
+    version_management_tool,
 ]

package/src/onemancompany/api/routes.py

@@ -7197,8 +7197,11 @@ async def api_list_issues(slug: str, status: str = "", priority: str = "") -> li
     from onemancompany.core import product as prod
     from onemancompany.core.models import IssuePriority, IssueStatus
 
-    status_filter = IssueStatus(status) if status else None
-    priority_filter = IssuePriority(priority) if priority else None
+    try:
+        status_filter = IssueStatus(status) if status else None
+        priority_filter = IssuePriority(priority) if priority else None
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
     return prod.list_issues(slug, status=status_filter, priority=priority_filter)
 
 
@@ -7223,13 +7226,17 @@ async def api_update_issue(slug: str, issue_id: str, request: Request) -> dict:
     ISSUE_MUTABLE_FIELDS = {"title", "status", "priority", "assignee_id", "labels", "milestone_version", "description", "story_points", "sprint"}
     body = await request.json()
     filtered = {k: v for k, v in body.items() if k in ISSUE_MUTABLE_FIELDS}
-    if "status" in filtered:
-        filtered["status"] = _IS(filtered["status"]).value
-    if "priority" in filtered:
-        filtered["priority"] = _IP2(filtered["priority"]).value
-    result = prod.update_issue(slug, issue_id, **filtered)
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Issue '{issue_id}' not found")
+    try:
+        if "status" in filtered:
+            filtered["status"] = _IS(filtered["status"]).value
+        if "priority" in filtered:
+            filtered["priority"] = _IP2(filtered["priority"]).value
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    try:
+        result = prod.update_issue(slug, issue_id, **filtered)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
 
     # Publish ISSUE_ASSIGNED event when assignee changes
     if "assignee_id" in filtered and filtered["assignee_id"]:
@@ -7257,9 +7264,14 @@ async def api_close_issue(slug: str, issue_id: str, request: Request) -> dict:
 
     body = await request.json() if request.headers.get("content-length", "0") != "0" else {}
     resolution_str = body.get("resolution", "fixed")
-    result = prod.close_issue(slug, issue_id, resolution=IssueResolution(resolution_str))
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Issue '{issue_id}' not found")
+    try:
+        resolution = IssueResolution(resolution_str)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    try:
+        result = prod.close_issue(slug, issue_id, resolution=resolution)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
     await event_bus.publish(
         CompanyEvent(
             type=EventType.ISSUE_CLOSED,
@@ -7275,9 +7287,10 @@ async def api_reopen_issue(slug: str, issue_id: str) -> dict:
     """Reopen a closed issue."""
     from onemancompany.core import product as prod
 
-    result = prod.reopen_issue(slug, issue_id)
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Issue '{issue_id}' not found")
+    try:
+        result = prod.reopen_issue(slug, issue_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
     return result
 
 

package/src/onemancompany/core/product.py

@@ -287,9 +287,11 @@ def create_issue(
     sprint: str | None = None,
 ) -> dict:
     """Create an issue for a product. Returns the issue dict."""
-    issue_id = _gen_id("issue_")
     product = load_product(slug)
-    product_id = product["id"] if product else ""
+    if not product:
+        raise ValueError(f"Product '{slug}' not found")
+    issue_id = _gen_id("issue_")
+    product_id = product["id"]
     now = datetime.now().isoformat()
 
     data = {
@@ -380,14 +382,19 @@ def list_issues(
     return results
 
 
-def update_issue(slug: str, issue_id: str, **fields) -> dict | None:
-    """Update issue fields. Returns updated dict or None if not found."""
+def update_issue(slug: str, issue_id: str, **fields) -> dict:
+    """Update issue fields. Returns updated dict. Raises ValueError if not found."""
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
         if not data:
-            logger.warning("update_issue: issue {} not found in {}", issue_id, slug)
-            return None
+            raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
+        # Validate status transition if status is being changed
+        new_status = fields.get("status")
+        if new_status is not None:
+            current_status = data.get("status", IssueStatus.BACKLOG.value)
+            if new_status != current_status:
+                _validate_status_transition(current_status, new_status)
         for key, value in fields.items():
             if value is not None:
                 old_value = data.get(key)
@@ -404,14 +411,13 @@ def close_issue(
     issue_id: str,
     *,
     resolution: IssueResolution = IssueResolution.FIXED,
-) -> dict | None:
-    """Close an issue with a resolution. Returns updated dict or None."""
+) -> dict:
+    """Close an issue with a resolution. Returns updated dict. Raises ValueError if not found."""
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
         if not data:
-            logger.warning("close_issue: issue {} not found in {}", issue_id, slug)
-            return None
+            raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
         old_status = data.get("status")
         _append_history(data, "status", old_status, IssueStatus.DONE.value, changed_by="system")
         data["status"] = IssueStatus.DONE.value
@@ -423,14 +429,13 @@ def close_issue(
     return data
 
 
-def reopen_issue(slug: str, issue_id: str) -> dict | None:
-    """Reopen a closed issue. Increments reopened_count. Returns updated dict or None."""
+def reopen_issue(slug: str, issue_id: str) -> dict:
+    """Reopen a closed issue. Increments reopened_count. Returns updated dict. Raises ValueError if not found."""
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
         if not data:
-            logger.warning("reopen_issue: issue {} not found in {}", issue_id, slug)
-            return None
+            raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
         old_status = data.get("status")
         _append_history(data, "status", old_status, IssueStatus.BACKLOG.value, changed_by="system")
         data["status"] = IssueStatus.BACKLOG.value
@@ -443,6 +448,53 @@ def reopen_issue(slug: str, issue_id: str) -> dict | None:
     return data
 
 
+def delete_issue(slug: str, issue_id: str) -> None:
+    """Delete an issue and clean up all links referencing it. Raises ValueError if not found."""
+    issue = load_issue(slug, issue_id)
+    if not issue:
+        raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
+
+    # Clean up links from other issues pointing to this one
+    all_issues = list_issues(slug)
+    for other in all_issues:
+        if other["id"] == issue_id:
+            continue
+        links = other.get("issue_links", [])
+        if any(l["issue_id"] == issue_id for l in links):
+            _remove_link_entry(slug, other["id"], issue_id)
+
+    # Remove the issue file
+    with _get_slug_lock(slug):
+        path = _issues_dir(slug) / f"{issue_id}.yaml"
+        path.unlink(missing_ok=True)
+    mark_dirty(DirtyCategory.PRODUCTS)
+    logger.debug("Deleted issue {} from {}", issue_id, slug)
+
+
+# ---------------------------------------------------------------------------
+# Issue Status Transitions
+# ---------------------------------------------------------------------------
+
+_VALID_TRANSITIONS: dict[str, set[str]] = {
+    IssueStatus.BACKLOG.value: {IssueStatus.PLANNED.value, IssueStatus.IN_PROGRESS.value},
+    IssueStatus.PLANNED.value: {IssueStatus.IN_PROGRESS.value, IssueStatus.BACKLOG.value},
+    IssueStatus.IN_PROGRESS.value: {IssueStatus.IN_REVIEW.value, IssueStatus.DONE.value, IssueStatus.BACKLOG.value},
+    IssueStatus.IN_REVIEW.value: {IssueStatus.DONE.value, IssueStatus.IN_PROGRESS.value, IssueStatus.BACKLOG.value},
+    IssueStatus.DONE.value: {IssueStatus.RELEASED.value, IssueStatus.BACKLOG.value},
+    IssueStatus.RELEASED.value: {IssueStatus.BACKLOG.value},
+}
+
+
+def _validate_status_transition(current: str, target: str) -> None:
+    """Raise ValueError if the status transition is not allowed."""
+    allowed = _VALID_TRANSITIONS.get(current, set())
+    if target not in allowed:
+        raise ValueError(
+            f"Invalid transition: '{current}' → '{target}'. "
+            f"Allowed: {sorted(allowed)}"
+        )
+
+
 # ---------------------------------------------------------------------------
 # Issue Links
 # ---------------------------------------------------------------------------
@@ -478,6 +530,13 @@ def add_issue_link(
     rel_value = relation.value if hasattr(relation, "value") else relation
     reverse_rel = _REVERSE_RELATION[rel_value]
 
+    # Circular dependency check for blocking relations
+    if rel_value == IssueRelation.BLOCKS.value:
+        _check_block_cycle(slug, issue_id, target_id)
+    elif rel_value == IssueRelation.BLOCKED_BY.value:
+        # blocked_by is the reverse: target blocks issue
+        _check_block_cycle(slug, target_id, issue_id)
+
     # Add forward link (idempotent)
     _add_link_entry(slug, issue_id, target_id, rel_value)
     # Add reverse link
@@ -487,6 +546,34 @@ def add_issue_link(
     logger.debug("Linked {} —{}→ {}", issue_id, rel_value, target_id)
 
 
+def _check_block_cycle(slug: str, blocker_id: str, blocked_id: str) -> None:
+    """Raise ValueError if adding 'blocker_id blocks blocked_id' would create a cycle.
+
+    Walks the existing 'blocks' graph starting from blocked_id to see if
+    blocker_id is reachable (meaning blocked_id already transitively blocks blocker_id).
+    """
+    visited: set[str] = set()
+    queue = [blocked_id]
+    while queue:
+        current = queue.pop()
+        if current in visited:
+            continue
+        visited.add(current)
+        issue = load_issue(slug, current)
+        if not issue:
+            continue
+        for link in issue.get("issue_links", []):
+            if link["relation"] != IssueRelation.BLOCKS.value:
+                continue
+            downstream = link["issue_id"]
+            if downstream == blocker_id:
+                raise ValueError(
+                    f"Circular dependency: {blocked_id} already transitively "
+                    f"blocks {blocker_id}"
+                )
+            queue.append(downstream)
+
+
 def _add_link_entry(slug: str, issue_id: str, target_id: str, relation: str) -> None:
     """Add a single link entry to an issue (idempotent)."""
     with _get_slug_lock(slug):
@@ -1215,6 +1302,17 @@ def create_sprint(
     if not product:
         raise ValueError(f"Product '{slug}' not found")
 
+    # Validate dates
+    try:
+        sd = datetime.strptime(start_date, "%Y-%m-%d")
+        ed = datetime.strptime(end_date, "%Y-%m-%d")
+    except ValueError as exc:
+        raise ValueError(f"Invalid date format: {exc}") from exc
+    if ed <= sd:
+        raise ValueError(
+            f"End date '{end_date}' must be after start date '{start_date}'"
+        )
+
     sprint_id = _gen_id("sprint_")
     now = datetime.now().isoformat()
 
@@ -1286,6 +1384,25 @@ def update_sprint(slug: str, sprint_id: str, **fields) -> dict:
     return sprint
 
 
+def start_sprint(slug: str, sprint_id: str) -> dict:
+    """Start a sprint (set status to active). Raises ValueError if already active elsewhere."""
+    return update_sprint(slug, sprint_id, status=SprintStatus.ACTIVE.value)
+
+
+def delete_sprint(slug: str, sprint_id: str) -> None:
+    """Delete a sprint. Cannot delete an active sprint. Raises ValueError if not found."""
+    sprint = load_sprint(slug, sprint_id)
+    if not sprint:
+        raise ValueError(f"Sprint '{sprint_id}' not found in '{slug}'")
+    if sprint.get("status") == SprintStatus.ACTIVE.value:
+        raise ValueError(f"Cannot delete active sprint '{sprint_id}'. Close it first.")
+    with _get_slug_lock(slug):
+        path = _sprints_dir(slug) / f"{sprint_id}.yaml"
+        path.unlink(missing_ok=True)
+    mark_dirty(DirtyCategory.PRODUCTS)
+    logger.debug("Deleted sprint {} from {}", sprint_id, slug)
+
+
 def get_active_sprint(slug: str) -> dict | None:
     """Return the current active sprint for a product, or None."""
     active = list_sprints(slug, status=SprintStatus.ACTIVE.value)