@0dai-dev/cli 4.3.5 → 4.3.7

package/scripts/build-tui.js

@@ -66,7 +66,20 @@ esbuild
     logLevel: "warning",
     minify: false,
     sourcemap: false,
-    banner: { js: "// @generated — do not edit. Source: lib/tui/src/" },
+    // ESM output for node: define require/__filename/__dirname so esbuild's
+    // __require shim resolves real node builtins instead of throwing
+    // "Dynamic require of \"assert\" is not supported" at import time (#4359).
+    banner: {
+      js: [
+        "// @generated — do not edit. Source: lib/tui/src/",
+        "import { createRequire as __odaiCreateRequire } from 'node:module';",
+        "import { fileURLToPath as __odaiFileURLToPath } from 'node:url';",
+        "import { dirname as __odaiDirname } from 'node:path';",
+        "const require = __odaiCreateRequire(import.meta.url);",
+        "const __filename = __odaiFileURLToPath(import.meta.url);",
+        "const __dirname = __odaiDirname(__filename);",
+      ].join("\n"),
+    },
   })
   .then(() => {
     console.log("[tui-build] wrote " + path.relative(ROOT, OUT));

package/scripts/harvest_experience.py

@@ -0,0 +1,523 @@
+#!/usr/bin/env python3
+"""0dai Harvest — transform experience events into scored candidates.
+
+Reads fallback events from ai/experience/events/*.json and *.jsonl,
+groups by (tool, task_type) patterns, and creates candidate markdown files
+in ai/experience/candidates/ for review and potential promotion.
+
+Usage:
+    python3 scripts/harvest_experience.py [--target <path>] [--explain]
+    0dai harvest --target . [--explain]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import time
+from collections import defaultdict
+
+REQUIRED_EVENT_FIELDS = (
+    "schema",
+    "event_id",
+    "timestamp",
+    "event_type",
+    "tool",
+    "task_type",
+    "summary",
+    "paths",
+    "ci_passed",
+    "source",
+)
+STRING_FIELDS = (
+    "event_id",
+    "timestamp",
+    "event_type",
+    "tool",
+    "task_type",
+    "summary",
+    "source",
+)
+IGNORED_EVENT_FILENAMES = {"example.jsonl"}
+HIGH_CONFIDENCE_EVENTS = 3
+MEDIUM_CONFIDENCE_EVENTS = 2
+SUCCESS_RESULTS = {"success", "partial", "passed", "ok", "done"}
+
+
+def _rel(target: pathlib.Path, path: pathlib.Path) -> str:
+    try:
+        return str(path.relative_to(target))
+    except ValueError:
+        return str(path)
+
+
+def _diagnostic(
+    path: str,
+    status: str,
+    reason: str,
+    *,
+    category: str = "discovery",
+) -> dict:
+    return {
+        "path": path,
+        "status": status,
+        "reason": reason,
+        "category": category,
+    }
+
+
+def _validate_event(event: object) -> list[str]:
+    """Return deterministic fallback-contract validation issues."""
+    if not isinstance(event, dict):
+        return ["event must be a JSON object"]
+
+    issues: list[str] = []
+    missing = [
+        field
+        for field in REQUIRED_EVENT_FIELDS
+        if field not in event or event.get(field) in (None, "")
+    ]
+    for field in missing:
+        issues.append(f"missing required field: {field}")
+
+    if "schema" not in missing and event.get("schema") != 1:
+        issues.append("schema must be 1")
+
+    for field in STRING_FIELDS:
+        if field not in missing and not isinstance(event.get(field), str):
+            issues.append(f"{field} must be a string")
+
+    if "paths" not in missing:
+        paths = event.get("paths")
+        if not isinstance(paths, list) or any(not isinstance(item, str) for item in paths):
+            issues.append("paths must be an array of strings")
+
+    if "ci_passed" not in missing and not isinstance(event.get("ci_passed"), bool):
+        issues.append("ci_passed must be a boolean")
+
+    return issues
+
+
+def _string_or_empty(value: object) -> str:
+    if value is None:
+        return ""
+    text = str(value).strip()
+    return text
+
+
+def _first_string(*values: object) -> str:
+    for value in values:
+        text = _string_or_empty(value)
+        if text:
+            return text
+    return ""
+
+
+def _string_list(value: object) -> list[str]:
+    if isinstance(value, str):
+        return [value] if value else []
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, str) and item]
+
+
+def _legacy_ci_passed(event: dict, task: dict, context: dict, quality: dict) -> bool:
+    for value in (
+        event.get("ci_passed"),
+        context.get("tests_passed"),
+        task.get("tests_passed"),
+        quality.get("acceptance_criteria_met"),
+    ):
+        if isinstance(value, bool):
+            return value
+    result = _first_string(task.get("result"), event.get("result"), event.get("status"))
+    return result.lower() in SUCCESS_RESULTS
+
+
+def _looks_like_structured_experience(event: dict) -> bool:
+    if "schema" in event:
+        return False
+    task = event.get("task")
+    if isinstance(task, dict) and (
+        "agent" in event
+        or "model" in event
+        or "project_id" in event
+        or "session_id" in event
+        or "context" in event
+        or "quality" in event
+    ):
+        return True
+    return False
+
+
+def _normalize_structured_experience(event: object) -> tuple[object, str | None]:
+    """Adapt experience_pipeline JSONL records to the harvest fallback schema.
+
+    `experience_pipeline.py` writes structured events with `agent` and nested
+    `task` blocks. Older harvest versions treated those as invalid fallback
+    records because they do not carry the MCP fallback fields directly.
+    """
+    if not isinstance(event, dict) or not _looks_like_structured_experience(event):
+        return event, None
+
+    task = event.get("task") if isinstance(event.get("task"), dict) else {}
+    context = event.get("context") if isinstance(event.get("context"), dict) else {}
+    quality = event.get("quality") if isinstance(event.get("quality"), dict) else {}
+
+    event_type = _first_string(event.get("event_type"), "task_completed")
+    tool = _first_string(event.get("tool"), event.get("agent"), task.get("agent"), "unknown")
+    task_type = _first_string(
+        event.get("task_type"),
+        task.get("task_type"),
+        task.get("type"),
+        "unknown",
+    )
+    summary = _first_string(
+        event.get("summary"),
+        task.get("goal"),
+        event.get("goal"),
+        event.get("title"),
+        f"{event_type} event from {tool}",
+    )
+    paths = (
+        _string_list(event.get("paths"))
+        or _string_list(task.get("paths"))
+        or _string_list(task.get("files"))
+        or _string_list(context.get("paths"))
+        or _string_list(context.get("files"))
+    )
+
+    normalized = {
+        "schema": 1,
+        "event_id": _first_string(event.get("event_id"), event.get("id")),
+        "timestamp": _first_string(event.get("timestamp"), event.get("ts")),
+        "event_type": event_type,
+        "tool": tool,
+        "task_type": task_type,
+        "summary": summary,
+        "paths": paths,
+        "ci_passed": _legacy_ci_passed(event, task, context, quality),
+        "source": _first_string(event.get("source"), "experience-pipeline-compat"),
+    }
+    return normalized, "compatible structured experience event (normalized to harvest schema)"
+
+
+def _append_event_or_diagnostic(
+    event: object,
+    rel_path: str,
+    events: list[dict],
+    diagnostics: list[dict],
+) -> None:
+    normalized, compatibility_reason = _normalize_structured_experience(event)
+    issues = _validate_event(normalized)
+    if issues:
+        diagnostics.append(
+            _diagnostic(
+                rel_path,
+                "skipped",
+                "; ".join(issues),
+                category="validation",
+            )
+        )
+        return
+
+    events.append(normalized)
+    diagnostics.append(
+        _diagnostic(
+            rel_path,
+            "kept",
+            compatibility_reason or "valid experience event",
+            category="compatibility" if compatibility_reason else "discovery",
+        )
+    )
+
+
+def _discover_events(target: pathlib.Path) -> tuple[list[dict], list[dict], int]:
+    """Walk ai/experience/events + ai/experience/outbox; return valid events plus explain records.
+
+    Note: `0dai task run` writes events to `ai/experience/outbox/` while
+    `record_experience` MCP tool writes to `ai/experience/events/`. Both are
+    legitimate event sources; harvest scans both so the smoke-test pipeline
+    (init → task run → harvest → candidate) works end-to-end. Mirrors the
+    pattern in `scripts/score_experience.py:86` which reads both directories.
+    """
+    experience_root = target / "ai" / "experience"
+    event_dirs = [
+        experience_root / "events",
+        experience_root / "outbox",
+    ]
+    existing_dirs = [d for d in event_dirs if d.is_dir()]
+    if not existing_dirs:
+        return (
+            [],
+            [
+                _diagnostic(
+                    "ai/experience/events/",
+                    "skipped",
+                    "directory missing (and outbox/ also missing)",
+                )
+            ],
+            0,
+        )
+
+    events: list[dict] = []
+    diagnostics: list[dict] = []
+    walked: set[str] = set()
+
+    iter_paths = sorted(p for d in existing_dirs for p in d.iterdir())
+    for path in iter_paths:
+        rel_path = _rel(target, path)
+        walked.add(rel_path)
+
+        if path.name in IGNORED_EVENT_FILENAMES:
+            diagnostics.append(
+                _diagnostic(rel_path, "skipped", "template example file")
+            )
+            continue
+        if path.is_dir():
+            diagnostics.append(_diagnostic(rel_path, "skipped", "directory"))
+            continue
+        if path.suffix not in {".json", ".jsonl"}:
+            diagnostics.append(
+                _diagnostic(rel_path, "skipped", "unsupported extension")
+            )
+            continue
+
+        try:
+            raw = path.read_text("utf-8")
+        except OSError as exc:
+            diagnostics.append(
+                _diagnostic(rel_path, "skipped", f"unreadable: {exc}", category="io")
+            )
+            continue
+
+        if path.suffix == ".json":
+            try:
+                event = json.loads(raw)
+            except json.JSONDecodeError as exc:
+                diagnostics.append(
+                    _diagnostic(
+                        rel_path,
+                        "skipped",
+                        f"invalid JSON: {exc.msg}",
+                        category="parse",
+                    )
+                )
+                continue
+            _append_event_or_diagnostic(event, rel_path, events, diagnostics)
+            continue
+
+        nonempty_lines = 0
+        for idx, raw_line in enumerate(raw.splitlines(), start=1):
+            line = raw_line.strip()
+            if not line:
+                continue
+            nonempty_lines += 1
+            line_path = f"{rel_path}:{idx}"
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError as exc:
+                diagnostics.append(
+                    _diagnostic(
+                        line_path,
+                        "skipped",
+                        f"invalid JSON: {exc.msg}",
+                        category="parse",
+                    )
+                )
+                continue
+            _append_event_or_diagnostic(event, line_path, events, diagnostics)
+        if nonempty_lines == 0:
+            diagnostics.append(_diagnostic(rel_path, "skipped", "empty JSONL file"))
+
+    return events, diagnostics, len(walked)
+
+
+def _load_events(target: pathlib.Path) -> list[dict]:
+    """Load all valid experience events (JSON files + JSONL lines)."""
+    events, _diagnostics, _walked = _discover_events(target)
+    return events
+
+
+def _group_events(events: list[dict]) -> dict[str, list[dict]]:
+    """Group events by (tool, task_type) pattern for candidate creation."""
+    groups: dict[str, list[dict]] = defaultdict(list)
+    for event in events:
+        tool = event.get("tool", "unknown")
+        task_type = event.get("task_type", "unknown")
+        key = f"{tool}-{task_type}"
+        groups[key].append(event)
+    return dict(groups)
+
+
+def _create_candidate(
+    key: str, events: list[dict], candidates_dir: pathlib.Path, *, dry_run: bool = False
+) -> pathlib.Path | None:
+    """Create a candidate markdown file from grouped events."""
+    if len(events) < 1:
+        return None
+
+    tool = events[0].get("tool", "unknown")
+    task_type = events[0].get("task_type", "unknown")
+    summaries = [e.get("summary", "") for e in events if e.get("summary")]
+    paths_seen: set[str] = set()
+    for e in events:
+        for p in e.get("paths", []):
+            paths_seen.add(p)
+    ci_passed = sum(1 for e in events if e.get("ci_passed", False))
+    event_ids = [e.get("event_id", "") for e in events if e.get("event_id")]
+
+    candidate_id = f"candidate.{key}"
+    filename = f"{candidate_id}.md"
+    dest = candidates_dir / filename
+
+    # Don't overwrite existing candidates — append new sources
+    if dest.is_file():
+        return None
+
+    today = time.strftime("%Y-%m-%d", time.gmtime())
+    scope_paths = sorted(paths_seen)[:10]
+
+    confidence = (
+        "high"
+        if len(events) >= HIGH_CONFIDENCE_EVENTS
+        else "medium" if len(events) >= MEDIUM_CONFIDENCE_EVENTS else "low"
+    )
+
+    content = f"""---
+id: {candidate_id}
+type: skill
+status: candidate
+tool: {tool}
+task_type: {task_type}
+confidence: {confidence}
+sources: [{', '.join(event_ids[:10])}]
+scope_paths: {json.dumps(scope_paths)}
+created: {today}
+---
+
+# Candidate: {tool} — {task_type}
+
+## Pattern
+
+Agent `{tool}` performed `{task_type}` tasks {len(events)} time(s).
+CI passed: {ci_passed}/{len(events)}.
+
+## Evidence
+
+{chr(10).join(f'- {s[:200]}' for s in summaries[:5])}
+
+## Affected Files
+
+{chr(10).join(f'- `{p}`' for p in scope_paths[:10])}
+"""
+
+    if not dry_run:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, "utf-8")
+    return dest
+
+
+def harvest(target: pathlib.Path, *, dry_run: bool = False) -> dict:
+    """Main harvest: events → candidates."""
+    events, diagnostics, files_walked = _discover_events(target)
+    events_rejected = _count_rejections(diagnostics)
+    if not events:
+        return {
+            "harvested": 0,
+            "events_read": 0,
+            "events_rejected": events_rejected,
+            "files_walked": files_walked,
+            "candidates_created": [],
+            "diagnostics": diagnostics,
+        }
+
+    groups = _group_events(events)
+    candidates_dir = target / "ai" / "experience" / "candidates"
+    created: list[str] = []
+
+    for key, group_events in groups.items():
+        path = _create_candidate(key, group_events, candidates_dir, dry_run=dry_run)
+        if path:
+            created.append(str(path.relative_to(target)))
+
+    return {
+        "harvested": len(created),
+        "events_read": len(events),
+        "events_rejected": events_rejected,
+        "files_walked": files_walked,
+        "groups": len(groups),
+        "candidates_created": created,
+        "diagnostics": diagnostics,
+    }
+
+
+def _count_rejections(diagnostics: list[dict]) -> int:
+    return sum(1 for item in diagnostics if item.get("category") in {"parse", "validation", "io"})
+
+
+def _print_explain(diagnostics: list[dict]) -> None:
+    for item in diagnostics:
+        print(
+            f"[harvest:explain] {item['path']} "
+            f"{item['status']}: {item['reason']}"
+        )
+
+
+def _print_rejections(diagnostics: list[dict], *, limit: int = 5) -> None:
+    rejected = [
+        item
+        for item in diagnostics
+        if item.get("category") in {"parse", "validation", "io"}
+    ]
+    if not rejected:
+        return
+    print(f"[harvest] skipped {len(rejected)} invalid event(s):")
+    for item in rejected[:limit]:
+        print(f"  {item['path']}: {item['reason']}")
+    if len(rejected) > limit:
+        print("  run with --explain for the full file list")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Harvest fallback experience events.")
+    parser.add_argument("--target", default=".")
+    parser.add_argument(
+        "--explain",
+        action="store_true",
+        help="List every walked file/line and why it was kept or skipped.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Report candidates without writing them.")
+    parser.add_argument("--json", action="store_true", help="Emit machine-readable harvest results.")
+    args = parser.parse_args(argv)
+
+    target = pathlib.Path(args.target).resolve()
+    result = harvest(target, dry_run=args.dry_run)
+
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0
+
+    if args.explain:
+        _print_explain(result["diagnostics"])
+
+    _print_rejections(result["diagnostics"])
+
+    if result["harvested"] == 0:
+        if result["events_read"] == 0:
+            print("[harvest] no valid events found in ai/experience/events/")
+            print("  Record events with: 0dai MCP tool record_experience")
+        else:
+            print(f"[harvest] {result['events_read']} event(s) read, no new candidates to create")
+            print("  Existing candidates already cover these patterns")
+    else:
+        for path in result["candidates_created"]:
+            prefix = "[harvest] would create" if args.dry_run else "[harvest] created"
+            print(f"{prefix} {path}")
+        print(f"\n{result['harvested']} candidate(s) created from {result['events_read']} event(s)")
+        print("Next: run 'python3 scripts/score_experience.py' to score and promote")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/postinstall.js

@@ -12,17 +12,23 @@ try {
 
   const pkg = require("../package.json");
   const v = pkg.version || "?";
+  const innerWidth = 41;
+  const horizontal = "\u2500".repeat(innerWidth);
+  const boxLine = (text = "") => {
+    const clipped = String(text).slice(0, innerWidth);
+    return "  \u2502" + clipped.padEnd(innerWidth) + "\u2502";
+  };
 
   console.log("");
-  console.log("  \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("  \u2502  0dai installed successfully! v" + v.padEnd(10) + "\u2502");
-  console.log("  \u2502                                         \u2502");
-  console.log("  \u2502  Get started:                           \u2502");
-  console.log("  \u2502    cd your-project                      \u2502");
-  console.log("  \u2502    0dai init                             \u2502");
-  console.log("  \u2502                                         \u2502");
-  console.log("  \u2502  Docs: https://0dai.dev/docs            \u2502");
-  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  console.log("  \u250c" + horizontal + "\u2510");
+  console.log(boxLine("  0dai installed successfully! v" + v));
+  console.log(boxLine());
+  console.log(boxLine("  Get started:"));
+  console.log(boxLine("    cd your-project"));
+  console.log(boxLine("    0dai init"));
+  console.log(boxLine());
+  console.log(boxLine("  Docs: https://0dai.dev/docs"));
+  console.log("  \u2514" + horizontal + "\u2518");
   console.log("");
 } catch (_) {
   // Never fail