@oneie/claude 0.7.0 → 0.8.0

package/scripts/do-tasks-bridge.py

@@ -1,366 +0,0 @@
-#!/usr/bin/env python3
-"""do-tasks-bridge — make /do an actor in the world's task queue (tasks-integration Wire B).
-
-The /do build queue (do-rank.py over text/*-todo.md + task-paths.json) and the world's
-task queue (tasks:announce / tasks:mine, subscriptions in D1) are two views of one thing.
-This bridge reconciles them in three directions:
-
-  C1 EMIT       do-rank's OPEN tasks → tasks:announce payloads (humans + agents see the
-                build queue; a saved lens / subscription then routes them — tasks-push). ✓
-  C2 INGEST     world tasks tagged with build-words → do-rank's pick (anyone can post
-                build work and /do will consider it).                             ✓
-  C3 RECONCILE  the local weight tier (task-paths.json path.strength) and the substrate
-                tier (path-context.context-strength) become ONE number.           ✓
-
-`--selftest` asserts ALL THREE — the plan-level kill-switch in text/tasks-bridge-todo.md.
-
-Design: text/tasks-integration.md § Wire B · text/loop-plan.md (task-paths.json ⇄ path.strength).
-"""
-import json
-import os
-import subprocess
-import sys
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-HERE = Path(__file__).resolve().parent
-DO_RANK = HERE / "do-rank.py"
-ROOT = HERE.parents[1]
-
-# Tags that route world tasks into /do's pick.  Must intersect a world task's tags.
-BUILD_WORDS = frozenset({
-    "builds", "build", "loop", "do", "tasks", "engine", "cycles",
-    "work", "code", "dev", "infrastructure", "platform",
-})
-
-
-# ── C1 EMIT — do-rank open tasks → tasks:announce payloads ────────────────────
-
-def tasks_json():
-    """The do-rank task seed (the JSON contract this bridge consumes). One source of
-    truth for the open-task set + their tags + learned weight — never re-parsed here."""
-    out = subprocess.run(
-        [sys.executable, str(DO_RANK), "--tasks-json"],
-        capture_output=True, text=True, check=True,
-    ).stdout
-    return json.loads(out)
-
-
-def emit_payloads(seed):
-    """Map do-rank's OPEN tasks to tasks:announce payloads. The shape matches the
-    resolver contract in one.ie/web/src/lib/resolvers/subscriptions.ts:
-        { taskId, tags[], title?, payload? }
-    Blocked tasks are excluded — they are not yet actionable, so announcing them would
-    wake a worker for work it cannot start. Weight rides in the payload (the receiver
-    fans by tag; the weight is what tasks:mine later ranks by)."""
-    payloads = []
-    for t in seed.get("tasks", []):
-        if t.get("taskStatus") != "open":
-            continue
-        tags = [x for x in t.get("tag", []) if x]
-        if not tags:
-            continue  # a task with no words can reach no follower — skip
-        payloads.append({
-            "taskId": t.get("tid", ""),
-            "tags": tags,
-            "title": t.get("name", ""),
-            "weight": t.get("weight", 50),
-            "dept": t.get("dept", ""),
-        })
-    return payloads
-
-
-# ── C2 INGEST — world tasks (by build-word) → do-rank queue ───────────────────
-
-def ingest(world_tasks):
-    """Filter world tasks tagged with build-words into do-rank-compatible task dicts.
-
-    world_tasks: list of task dicts in the tasks:mine / tasks:announce shape:
-        { id: str, name: str, tags: [str], weight: int, status?: str }
-    Returns: list of do-rank task dicts (tid, name, tag, taskStatus, weight, dept)
-        ready to be merged into do-rank's pick alongside local text/*-todo.md tasks.
-
-    Only tasks whose tags intersect BUILD_WORDS reach /do's queue.  Blocked tasks
-    and tag-less tasks are already excluded by the world-side resolver; this filter
-    adds the semantic gate (build-domain only, not sales/service/etc.).
-    """
-    result = []
-    for t in world_tasks:
-        tags = [x for x in t.get("tags", []) if x]
-        if not any(w in BUILD_WORDS for w in tags):
-            continue  # no build-word → not for /do's pick
-        result.append({
-            "tid": t.get("id", ""),
-            "name": t.get("name", ""),
-            "tag": tags,
-            "taskStatus": t.get("status", "open"),
-            "weight": t.get("weight", 50),
-            "dept": "builds",  # world build-word tasks land in builds dept
-        })
-    return result
-
-
-# ── C3 RECONCILE — task-paths.json ⇄ substrate path-context.context-strength ──
-
-_RECONCILE_TOLERANCE = 0.05  # divergence below this is noise — don't write
-
-def reconcile(local, substrate):
-    """Merge local task-paths.json strength with substrate context-strength into one number.
-
-    local:     { "task:<slug>": {strength, resistance, traversals, closed} }
-               — the on-disk tier written by do-rank.py --mark / --sync-closes
-    substrate: { word: context_strength }
-               — from TypeDB path-context.context-strength via readContextStrength()
-               (subscriptions.ts:144), keyed by the word the path-context entity carries
-
-    Strategy: for each local task, derive its implied substrate score by looking up the
-    max context-strength across the words in its slug.  If substrate_score > local net
-    strength (closed + strength − resistance), raise local.strength so both tiers agree
-    and the next do-rank pick reflects the substrate's learned knowledge.
-
-    Returns a copy of `local` with updated `strength` fields.  The caller is responsible
-    for writing it back to task-paths.json (do-rank.py --sync-closes idiom).
-
-    Unidirectional: substrate → local only.  The reverse direction (local → substrate)
-    happens via do-rank.py --mark which calls mark() over HTTP, already shipped.
-    """
-    merged = {k: dict(v) for k, v in local.items()}  # shallow-copy each entry
-
-    for key, entry in merged.items():
-        # key shape: "task:<slug>" — split slug words (hyphen-separated)
-        slug = key[len("task:"):] if key.startswith("task:") else key
-        slug_words = [w for w in slug.replace("-", " ").split() if w]
-
-        substrate_scores = [substrate[w] for w in slug_words if w in substrate]
-        if not substrate_scores:
-            continue
-
-        substrate_strength = max(substrate_scores)
-        local_net = (
-            float(entry.get("closed", 0))
-            + float(entry.get("strength", 0))
-            - float(entry.get("resistance", 0))
-        )
-
-        if substrate_strength > local_net + _RECONCILE_TOLERANCE:
-            # Substrate learned this word is stronger than local records — sync up
-            entry["strength"] = round(
-                max(float(entry.get("strength", 0)), substrate_strength), 3
-            )
-
-    return merged
-
-
-# ── send — do-rank's OPEN tasks → delivered tasks:announce calls (code-signals wire 3) ──
-# Same auth + identity pairing as .claude/hooks/lib/signal.sh's emit_world (see
-# text/code-signals-plan.md): the local dev server reads secrets from .dev.vars (a
-# DIFFERENT value than .env — verified 2026-07-02), so which file to read must match
-# ONE_API_URL's target. slug:"one" + board:"marketplace" let this service-nominated
-# sender reach a subscriber registered under a different actor (fanOut never delivers
-# to its own sender — tag-match.ts).
-
-def _one_env_file():
-    override = os.environ.get("DO_ENV_FILE")
-    if override:
-        return Path(override)
-    url = os.environ.get("ONE_API_URL", "http://localhost:4321")
-    web = ROOT / "one.ie" / "web"
-    return web / ".dev.vars" if ("localhost" in url or "127.0.0.1" in url) else web / ".env"
-
-
-def _one_secret(name):
-    val = os.environ.get(name)
-    if val:
-        return val
-    f = _one_env_file()
-    if not f.is_file():
-        return ""
-    prefix = f"{name}="
-    for line in f.read_text().splitlines():
-        if line.startswith(prefix):
-            return line[len(prefix):].strip().strip('"')
-    return ""
-
-
-def tag_for_bridge(payload):
-    """Append 'cc' to a payload's tags (dedup, order-preserving) — marks it as a
-    code-signal, so the standing ['cc','session'] subscription (wire 2) catches wire 3's
-    task announces too, without widening what the subscription itself follows."""
-    tags = list(dict.fromkeys([*payload.get("tags", []), "cc"]))
-    return {**payload, "tags": tags, "slug": "one", "board": "marketplace"}
-
-
-def send_payloads(payloads, dry_run=False):
-    """POST each payload to tasks:announce. Returns one result dict per payload —
-    either the parsed {outcome,result:{ok,matched,...}} response, or {"dry_run":True,
-    "payload":...} when dry_run (no network, provable by inspection)."""
-    url = os.environ.get("ONE_API_URL", "http://localhost:4321") + "/api/ask/tasks:announce"
-    api_key = _one_secret("GATEWAY_API_KEY") if not dry_run else ""
-    results = []
-    for payload in payloads:
-        tagged = tag_for_bridge(payload)
-        if dry_run:
-            results.append({"dry_run": True, "payload": tagged})
-            continue
-        headers = {"Content-Type": "application/json"}
-        if api_key:
-            headers["Authorization"] = f"Bearer {api_key}"
-        req = urllib.request.Request(
-            url, data=json.dumps({"data": tagged}).encode(), method="POST", headers=headers,
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=5) as resp:
-                results.append(json.loads(resp.read().decode()))
-        except urllib.error.URLError as e:
-            results.append({"error": str(e)})
-    return results
-
-
-# ── selftest — the plan kill-switch (all three; RED until C3) ─────────────────
-
-def _check_emit():
-    """Emit round-trip on a fixture in the do-rank --tasks-json contract shape."""
-    seed = {
-        "tasks": [
-            {"tid": "task:alpha", "name": "Alpha", "tag": ["builds", "loop"],
-             "taskStatus": "open", "weight": 72, "dept": "builds"},
-            {"tid": "task:beta", "name": "Beta", "tag": ["sales"],
-             "taskStatus": "blocked", "weight": 50, "dept": "sales"},      # excluded (blocked)
-            {"tid": "task:gamma", "name": "Gamma", "tag": [],
-             "taskStatus": "open", "weight": 50, "dept": "builds"},        # excluded (no words)
-        ],
-    }
-    out = emit_payloads(seed)
-    if len(out) != 1:
-        return False, f"expected 1 open+tagged payload, got {len(out)}"
-    p = out[0]
-    if p["taskId"] != "task:alpha":
-        return False, f"wrong task emitted: {p['taskId']}"
-    if set(p["tags"]) != {"builds", "loop"}:
-        return False, f"tags not preserved: {p['tags']}"
-    if p["weight"] != 72:
-        return False, f"weight not preserved: {p['weight']}"
-    # contract: every payload carries the fields tasks:announce requires
-    if not (p["taskId"] and p["tags"]):
-        return False, "payload missing taskId/tags (tasks:announce contract)"
-    return True, "emit: open+tagged tasks → tasks:announce payloads, weight preserved"
-
-
-def _check_ingest():
-    world = [
-        # ✓ build-word hit → ingested
-        {"id": "world:1", "name": "Build the loop", "tags": ["builds", "loop"], "weight": 80, "status": "open"},
-        # ✗ no build-word → excluded
-        {"id": "world:2", "name": "Sales email", "tags": ["sales", "email"], "weight": 60, "status": "open"},
-        # ✓ build-word hit → ingested
-        {"id": "world:3", "name": "Coding tasks", "tags": ["code", "tasks"], "weight": 70, "status": "open"},
-        # ✗ no tags → excluded
-        {"id": "world:4", "name": "Empty", "tags": [], "weight": 50, "status": "open"},
-    ]
-    out = ingest(world)
-    if len(out) != 2:
-        return False, f"expected 2 build-word tasks, got {len(out)}: {[t['tid'] for t in out]}"
-    tids = {t["tid"] for t in out}
-    if tids != {"world:1", "world:3"}:
-        return False, f"wrong tasks ingested: {tids}"
-    if any(t["dept"] != "builds" for t in out):
-        return False, f"dept not 'builds' for all: {[t['dept'] for t in out]}"
-    return True, "ingest: build-word tasks selected + shaped, non-build + no-tag excluded"
-
-
-def _check_reconcile():
-    local = {
-        # local_net = 0.5 + 1.0 - 0.5 = 1.0 ; substrate max(loop=3.5) = 3.5 → update
-        "task:loop-plan": {"strength": 1.0, "resistance": 0.5, "traversals": 3, "closed": 0.5},
-        # local_net = 2.0 + 0.0 - 0.0 = 2.0 ; substrate max(tasks=2.0) = 2.0 → within tolerance, no-op
-        "task:tasks-bridge": {"strength": 0.0, "resistance": 0.0, "traversals": 0, "closed": 2.0},
-        # no substrate entry for any word → unchanged
-        "task:pay-links": {"strength": 0.5, "resistance": 0.0, "traversals": 1, "closed": 0.0},
-    }
-    substrate = {"loop": 3.5, "plan": 0.5, "tasks": 2.0, "bridge": 1.5}
-    merged = reconcile(local, substrate)
-
-    lp = merged.get("task:loop-plan", {})
-    if lp.get("strength", 0) < 3.0:
-        return False, f"loop-plan strength not raised from substrate: {lp}"
-    tb = merged.get("task:tasks-bridge", {})
-    if tb.get("strength", 0) != 0.0:
-        return False, f"tasks-bridge strength should be unchanged (within tolerance): {tb}"
-    pl = merged.get("task:pay-links", {})
-    if pl.get("strength") != 0.5:
-        return False, f"pay-links strength should be unchanged (no substrate word): {pl}"
-    return True, "reconcile: substrate-stronger words raise local tier; equal/weaker and no-match are untouched"
-
-
-def selftest():
-    checks = [
-        ("emit", _check_emit()),
-        ("ingest", _check_ingest()),
-        ("reconcile", _check_reconcile()),
-    ]
-    passed = 0
-    for name, (ok, msg) in checks:
-        print(f"  {'✓' if ok else '✗'} {name:<10} {msg}")
-        passed += 1 if ok else 0
-    print(f"SELFTEST: {passed}/{len(checks)} pass "
-          f"({'bridge complete' if passed == len(checks) else 'C2 ingest + C3 reconcile remain'})")
-    return 0 if passed == len(checks) else 1
-
-
-def main():
-    args = sys.argv[1:]
-    if "--selftest" in args:
-        sys.exit(selftest())
-    if "--emit" in args:
-        print(json.dumps(emit_payloads(tasks_json()), indent=2))
-        return
-    if "--send" in args:
-        dry_run = "--dry-run" in args
-        payloads = emit_payloads(tasks_json())
-        if not payloads:
-            print("[]")
-            print("send: 0 open+tagged task(s) — nothing to announce", file=sys.stderr)
-            return
-        results = send_payloads(payloads, dry_run=dry_run)
-        print(json.dumps(results, indent=2))
-        if not dry_run:
-            ok = sum(
-                1 for r in results
-                if isinstance(r, dict) and r.get("outcome") == "result" and r.get("result", {}).get("ok")
-            )
-            print(f"send: {ok}/{len(results)} task(s) announced ok", file=sys.stderr)
-        return
-    if "--ingest" in args:
-        # Read world tasks from stdin (JSON array) or print usage
-        try:
-            world_tasks = json.load(sys.stdin)
-        except (json.JSONDecodeError, ValueError) as e:
-            print(f"error: --ingest reads a JSON array of world tasks from stdin: {e}", file=sys.stderr)
-            sys.exit(1)
-        print(json.dumps(ingest(world_tasks), indent=2))
-        return
-    if "--reconcile" in args:
-        # Read substrate context-strength map from stdin: {"word": strength}
-        try:
-            substrate = json.load(sys.stdin)
-        except (json.JSONDecodeError, ValueError) as e:
-            print(f"error: --reconcile reads a JSON {{word: strength}} map from stdin: {e}", file=sys.stderr)
-            sys.exit(1)
-        from pathlib import Path as _P
-        task_paths_file = _P(__file__).resolve().parents[2] / "text" / "task-paths.json"
-        try:
-            local = json.loads(task_paths_file.read_text())
-        except (FileNotFoundError, ValueError):
-            local = {}
-        merged = reconcile(local, substrate)
-        task_paths_file.write_text(json.dumps(merged, indent=2, sort_keys=True) + "\n")
-        changed = sum(1 for k in merged if merged[k].get("strength") != local.get(k, {}).get("strength"))
-        print(f"reconciled {changed} task(s) from substrate context-strength → {task_paths_file.name}")
-        return
-    print(__doc__)
-    print("usage: do-tasks-bridge.py [--emit | --send [--dry-run] | --ingest | --reconcile | --selftest]")
-
-
-if __name__ == "__main__":
-    main()

package/scripts/node_modules/@anthropic-ai/sdk/.github/logo.svg

@@ -1,3 +0,0 @@
-<svg width="248" height="248" viewBox="0 0 248 248" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M52.4285 162.873L98.7844 136.879L99.5485 134.602L98.7844 133.334H96.4921L88.7237 132.862L62.2346 132.153L39.3113 131.207L17.0249 130.026L11.4214 128.844L6.2 121.873L6.7094 118.447L11.4214 115.257L18.171 115.847L33.0711 116.911L55.485 118.447L71.6586 119.392L95.728 121.873H99.5485L100.058 120.337L98.7844 119.392L97.7656 118.447L74.5877 102.732L49.4995 86.1905L36.3823 76.62L29.3779 71.7757L25.8121 67.2858L24.2839 57.3608L30.6515 50.2716L39.3113 50.8623L41.4763 51.4531L50.2636 58.1879L68.9842 72.7209L93.4357 90.6804L97.0015 93.6343L98.4374 92.6652L98.6571 91.9801L97.0015 89.2625L83.757 65.2772L69.621 40.8192L63.2534 30.6579L61.5978 24.632C60.9565 22.1032 60.579 20.0111 60.579 17.4246L67.8381 7.49965L71.9133 6.19995L81.7193 7.49965L85.7946 11.0443L91.9074 24.9865L101.714 46.8451L116.996 76.62L121.453 85.4816L123.873 93.6343L124.764 96.1155H126.292V94.6976L127.566 77.9197L129.858 57.3608L132.15 30.8942L132.915 23.4505L136.608 14.4708L143.994 9.62643L149.725 12.344L154.437 19.0788L153.8 23.4505L150.998 41.6463L145.522 70.1215L141.957 89.2625H143.994L146.414 86.7813L156.093 74.0206L172.266 53.698L179.398 45.6635L187.803 36.802L193.152 32.5484H203.34L210.726 43.6549L207.415 55.1159L196.972 68.3492L188.312 79.5739L175.896 96.2095L168.191 109.585L168.882 110.689L170.738 110.53L198.755 104.504L213.91 101.787L231.994 98.7149L240.144 102.496L241.036 106.395L237.852 114.311L218.495 119.037L195.826 123.645L162.07 131.592L161.696 131.893L162.137 132.547L177.36 133.925L183.855 134.279H199.774L229.447 136.524L237.215 141.605L241.8 147.867L241.036 152.711L229.065 158.737L213.019 154.956L175.45 145.977L162.587 142.787H160.805V143.85L171.502 154.366L191.242 172.089L215.82 195.011L217.094 200.682L213.91 205.172L210.599 204.699L188.949 188.394L180.544 181.069L161.696 165.118H160.422V166.772L164.752 173.152L187.803 207.771L188.949 218.405L187.294 221.832L181.308 223.959L174.813 222.777L161.187 203.754L147.305 182.486L136.098 163.345L134.745 164.2L128.075 235.42L125.019 239.082L117.887 241.8L111.902 237.31L108.718 229.984L111.902 215.452L115.722 196.547L118.779 181.541L121.58 162.873L123.291 156.636L123.14 156.219L121.773 156.449L107.699 175.752L86.304 204.699L69.3663 222.777L65.291 224.431L58.2867 220.768L58.9235 214.27L62.8713 208.48L86.304 178.705L100.44 160.155L109.551 149.507L109.462 147.967L108.959 147.924L46.6977 188.512L35.6182 189.93L30.7788 185.44L31.4156 178.115L33.7079 175.752L52.4285 162.873Z" fill="#D97757"/>
-</svg>