m3taversal
8f6057686e
The regex fallback was writing list entries as ' - "title"' (2-space indent + quotes) while existing frontmatter uses '- title' (0-space indent, no quotes). This caused YAML parse failures during merge. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
972 lines
36 KiB
Python
972 lines
36 KiB
Python
#!/usr/bin/env python3
|
|
"""Orphan Reweave — connect isolated claims via vector similarity + Haiku classification.
|
|
|
|
Finds claims with zero incoming links (orphans), uses Qdrant to find semantically
|
|
similar neighbors, classifies the relationship with Haiku, and writes edges on the
|
|
neighbor's frontmatter pointing TO the orphan.
|
|
|
|
Usage:
|
|
python3 reweave.py --dry-run # Show what would be connected
|
|
python3 reweave.py --max-orphans 50 # Process up to 50 orphans
|
|
python3 reweave.py --threshold 0.72 # Override similarity floor
|
|
|
|
Design:
|
|
- Orphan = zero incoming links (no other claim's supports/challenges/related/depends_on points to it)
|
|
- Write edge on NEIGHBOR (not orphan) so orphan gains an incoming link
|
|
- Haiku classifies: supports | challenges | related (>=0.85 confidence for supports/challenges)
|
|
- reweave_edges parallel field for tooling-readable provenance
|
|
- Single PR per run for Leo review
|
|
|
|
Pentagon-Agent: Epimetheus <0144398e-4ed3-4fe2-95a3-3d72e1abf887>
|
|
"""
|
|
|
|
import argparse
|
|
import datetime
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import urllib.request
|
|
from pathlib import Path
|
|
|
|
import yaml
|
|
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
|
|
logger = logging.getLogger("reweave")
|
|
|
|
# --- Config ---
|
|
REPO_DIR = Path(os.environ.get("REPO_DIR", "/opt/teleo-eval/workspaces/main"))
|
|
SECRETS_DIR = Path(os.environ.get("SECRETS_DIR", "/opt/teleo-eval/secrets"))
|
|
QDRANT_URL = os.environ.get("QDRANT_URL", "http://localhost:6333")
|
|
QDRANT_COLLECTION = os.environ.get("QDRANT_COLLECTION", "teleo-claims")
|
|
FORGEJO_URL = os.environ.get("FORGEJO_URL", "http://localhost:3000")
|
|
|
|
EMBED_DIRS = ["domains", "core", "foundations", "decisions", "entities"]
|
|
EDGE_FIELDS = ("supports", "challenges", "challenged_by", "depends_on", "related")
|
|
WIKI_LINK_RE = re.compile(r"\[\[([^\]]+)\]\]")
|
|
|
|
# Thresholds (from calibration data — Mar 28)
|
|
DEFAULT_THRESHOLD = 0.70 # Elbow in score distribution
|
|
DEFAULT_MAX_ORPHANS = 50 # Keep PRs reviewable
|
|
DEFAULT_MAX_NEIGHBORS = 3 # Don't over-connect
|
|
HAIKU_CONFIDENCE_FLOOR = 0.85 # Below this → default to "related"
|
|
PER_FILE_EDGE_CAP = 10 # Max total reweave edges per neighbor file
|
|
|
|
# Domain processing order: diversity first, internet-finance last (Leo)
|
|
DOMAIN_PRIORITY = [
|
|
"ai-alignment", "health", "space-development", "entertainment",
|
|
"creative-industries", "collective-intelligence", "governance",
|
|
# internet-finance last — batch-imported futarchy cluster, lower cross-domain value
|
|
"internet-finance",
|
|
]
|
|
|
|
|
|
# ─── Orphan Detection ────────────────────────────────────────────────────────
|
|
|
|
|
|
def _parse_frontmatter(path: Path) -> dict | None:
|
|
"""Parse YAML frontmatter from a markdown file. Returns dict or None."""
|
|
try:
|
|
text = path.read_text(errors="replace")
|
|
except Exception:
|
|
return None
|
|
if not text.startswith("---"):
|
|
return None
|
|
end = text.find("\n---", 3)
|
|
if end == -1:
|
|
return None
|
|
try:
|
|
fm = yaml.safe_load(text[3:end])
|
|
return fm if isinstance(fm, dict) else None
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _get_body(path: Path) -> str:
|
|
"""Get body text (after frontmatter) from a markdown file."""
|
|
try:
|
|
text = path.read_text(errors="replace")
|
|
except Exception:
|
|
return ""
|
|
if not text.startswith("---"):
|
|
return text
|
|
end = text.find("\n---", 3)
|
|
if end == -1:
|
|
return text
|
|
return text[end + 4:].strip()
|
|
|
|
|
|
def _get_edge_targets(path: Path) -> list[str]:
|
|
"""Extract all outgoing edge targets from a claim's frontmatter + wiki links."""
|
|
targets = []
|
|
fm = _parse_frontmatter(path)
|
|
if fm:
|
|
for field in EDGE_FIELDS:
|
|
val = fm.get(field)
|
|
if isinstance(val, list):
|
|
targets.extend(str(v).strip().lower() for v in val if v)
|
|
elif isinstance(val, str) and val.strip():
|
|
targets.append(val.strip().lower())
|
|
# Also check reweave_edges (from previous runs)
|
|
rw = fm.get("reweave_edges")
|
|
if isinstance(rw, list):
|
|
targets.extend(str(v).strip().lower() for v in rw if v)
|
|
|
|
# Wiki links in body
|
|
try:
|
|
text = path.read_text(errors="replace")
|
|
end = text.find("\n---", 3)
|
|
if end > 0:
|
|
body = text[end + 4:]
|
|
for link in WIKI_LINK_RE.findall(body):
|
|
targets.append(link.strip().lower())
|
|
except Exception:
|
|
pass
|
|
|
|
return targets
|
|
|
|
|
|
def _claim_name_variants(path: Path, repo_root: Path = None) -> list[str]:
|
|
"""Generate name variants for a claim file (used for incoming link matching).
|
|
|
|
A claim at domains/ai-alignment/rlhf-reward-hacking.md could be referenced as:
|
|
- "rlhf-reward-hacking"
|
|
- "rlhf reward hacking"
|
|
- "RLHF reward hacking" (title case)
|
|
- The actual 'name' or 'title' from frontmatter
|
|
- "domains/ai-alignment/rlhf-reward-hacking" (relative path without .md)
|
|
"""
|
|
variants = set()
|
|
stem = path.stem
|
|
variants.add(stem.lower())
|
|
variants.add(stem.lower().replace("-", " "))
|
|
|
|
# Also match by relative path (Ganymede Q1: some edges use path references)
|
|
if repo_root:
|
|
try:
|
|
rel = str(path.relative_to(repo_root)).removesuffix(".md")
|
|
variants.add(rel.lower())
|
|
except ValueError:
|
|
pass
|
|
|
|
fm = _parse_frontmatter(path)
|
|
if fm:
|
|
for key in ("name", "title"):
|
|
val = fm.get(key)
|
|
if isinstance(val, str) and val.strip():
|
|
variants.add(val.strip().lower())
|
|
|
|
return list(variants)
|
|
|
|
|
|
def _is_entity(path: Path) -> bool:
|
|
"""Check if a file is an entity (not a claim). Entities need different edge vocabulary."""
|
|
fm = _parse_frontmatter(path)
|
|
if fm and fm.get("type") == "entity":
|
|
return True
|
|
# Check path parts — avoids false positives on paths like "domains/entities-overview/"
|
|
return "entities" in Path(path).parts
|
|
|
|
|
|
def _same_source(path_a: Path, path_b: Path) -> bool:
|
|
"""Check if two claims derive from the same source material.
|
|
|
|
Prevents self-referential edges where N claims about the same paper
|
|
all "support" each other — inflates graph density without adding information.
|
|
"""
|
|
fm_a = _parse_frontmatter(path_a)
|
|
fm_b = _parse_frontmatter(path_b)
|
|
if not fm_a or not fm_b:
|
|
return False
|
|
|
|
# Check source field
|
|
src_a = fm_a.get("source") or fm_a.get("source_file") or ""
|
|
src_b = fm_b.get("source") or fm_b.get("source_file") or ""
|
|
if src_a and src_b and str(src_a).strip() == str(src_b).strip():
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def find_all_claims(repo_root: Path) -> list[Path]:
|
|
"""Find all knowledge files (claim, framework, entity, decision) in the KB."""
|
|
claims = []
|
|
for d in EMBED_DIRS:
|
|
base = repo_root / d
|
|
if not base.is_dir():
|
|
continue
|
|
for md in base.rglob("*.md"):
|
|
if md.name.startswith("_"):
|
|
continue
|
|
fm = _parse_frontmatter(md)
|
|
if fm and fm.get("type") not in ("source", "musing", None):
|
|
claims.append(md)
|
|
return claims
|
|
|
|
|
|
def build_reverse_link_index(claims: list[Path]) -> dict[str, set[Path]]:
|
|
"""Build a reverse index: claim_name_variant → set of files that link TO it.
|
|
|
|
For each claim, extract all outgoing edges. For each target name, record
|
|
the source claim as an incoming link for that target.
|
|
"""
|
|
# name_variant → set of source paths that point to it
|
|
incoming: dict[str, set[Path]] = {}
|
|
|
|
for claim_path in claims:
|
|
targets = _get_edge_targets(claim_path)
|
|
for target in targets:
|
|
if target not in incoming:
|
|
incoming[target] = set()
|
|
incoming[target].add(claim_path)
|
|
|
|
return incoming
|
|
|
|
|
|
def find_orphans(claims: list[Path], incoming: dict[str, set[Path]],
|
|
repo_root: Path = None) -> list[Path]:
|
|
"""Find claims with zero incoming links."""
|
|
orphans = []
|
|
for claim_path in claims:
|
|
variants = _claim_name_variants(claim_path, repo_root)
|
|
has_incoming = any(
|
|
len(incoming.get(v, set()) - {claim_path}) > 0
|
|
for v in variants
|
|
)
|
|
if not has_incoming:
|
|
orphans.append(claim_path)
|
|
return orphans
|
|
|
|
|
|
def sort_orphans_by_domain(orphans: list[Path], repo_root: Path) -> list[Path]:
|
|
"""Sort orphans by domain priority (diversity first, internet-finance last)."""
|
|
def domain_key(path: Path) -> tuple[int, str]:
|
|
rel = path.relative_to(repo_root)
|
|
parts = rel.parts
|
|
domain = ""
|
|
if len(parts) >= 2 and parts[0] in ("domains", "entities", "decisions"):
|
|
domain = parts[1]
|
|
elif parts[0] == "foundations" and len(parts) >= 2:
|
|
domain = parts[1]
|
|
elif parts[0] == "core":
|
|
domain = "core"
|
|
|
|
try:
|
|
priority = DOMAIN_PRIORITY.index(domain)
|
|
except ValueError:
|
|
# Unknown domain goes before internet-finance but after known ones
|
|
priority = len(DOMAIN_PRIORITY) - 1
|
|
|
|
return (priority, path.stem)
|
|
|
|
return sorted(orphans, key=domain_key)
|
|
|
|
|
|
# ─── Qdrant Search ───────────────────────────────────────────────────────────
|
|
|
|
|
|
def _get_api_key() -> str:
|
|
"""Load OpenRouter API key."""
|
|
key_file = SECRETS_DIR / "openrouter-key"
|
|
if key_file.exists():
|
|
return key_file.read_text().strip()
|
|
key = os.environ.get("OPENROUTER_API_KEY", "")
|
|
if key:
|
|
return key
|
|
logger.error("No OpenRouter API key found")
|
|
sys.exit(1)
|
|
|
|
|
|
def make_point_id(rel_path: str) -> str:
|
|
"""Deterministic point ID from repo-relative path (matches embed-claims.py)."""
|
|
return hashlib.md5(rel_path.encode()).hexdigest()
|
|
|
|
|
|
def get_vector_from_qdrant(rel_path: str) -> list[float] | None:
|
|
"""Retrieve a claim's existing vector from Qdrant by its point ID."""
|
|
point_id = make_point_id(rel_path)
|
|
body = json.dumps({"ids": [point_id], "with_vector": True}).encode()
|
|
req = urllib.request.Request(
|
|
f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}/points",
|
|
data=body,
|
|
headers={"Content-Type": "application/json"},
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=10) as resp:
|
|
data = json.loads(resp.read())
|
|
points = data.get("result", [])
|
|
if points and points[0].get("vector"):
|
|
return points[0]["vector"]
|
|
except Exception as e:
|
|
logger.warning("Qdrant point lookup failed for %s: %s", rel_path, e)
|
|
return None
|
|
|
|
|
|
def search_neighbors(vector: list[float], exclude_path: str,
|
|
threshold: float, limit: int) -> list[dict]:
|
|
"""Search Qdrant for nearest neighbors above threshold, excluding self."""
|
|
body = {
|
|
"vector": vector,
|
|
"limit": limit + 5, # over-fetch to account for self + filtered
|
|
"with_payload": True,
|
|
"score_threshold": threshold,
|
|
"filter": {
|
|
"must_not": [{"key": "claim_path", "match": {"value": exclude_path}}]
|
|
},
|
|
}
|
|
req = urllib.request.Request(
|
|
f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}/points/search",
|
|
data=json.dumps(body).encode(),
|
|
headers={"Content-Type": "application/json"},
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=10) as resp:
|
|
data = json.loads(resp.read())
|
|
hits = data.get("result", [])
|
|
return hits[:limit]
|
|
except Exception as e:
|
|
logger.warning("Qdrant search failed: %s", e)
|
|
return []
|
|
|
|
|
|
# ─── Haiku Edge Classification ───────────────────────────────────────────────
|
|
|
|
|
|
CLASSIFY_PROMPT = """You are classifying the relationship between two knowledge claims.
|
|
|
|
CLAIM A (the orphan — needs to be connected):
|
|
Title: {orphan_title}
|
|
Body: {orphan_body}
|
|
|
|
CLAIM B (the neighbor — already connected in the knowledge graph):
|
|
Title: {neighbor_title}
|
|
Body: {neighbor_body}
|
|
|
|
What is the relationship FROM Claim B TO Claim A?
|
|
|
|
Options:
|
|
- "supports" — Claim B provides evidence, reasoning, or examples that strengthen Claim A
|
|
- "challenges" — Claim B contradicts, undermines, or provides counter-evidence to Claim A. NOTE: "challenges" is underused — if one claim says X works and another says X fails, or they propose incompatible mechanisms, that IS a challenge. Use it.
|
|
- "related" — Claims are topically connected but neither supports nor challenges the other. This is the WEAKEST edge — prefer supports/challenges when the relationship has directionality.
|
|
|
|
Respond with EXACTLY this JSON format, nothing else:
|
|
{{"edge_type": "supports|challenges|related", "confidence": 0.0-1.0, "reason": "one sentence explanation"}}
|
|
"""
|
|
|
|
|
|
def classify_edge(orphan_title: str, orphan_body: str,
|
|
neighbor_title: str, neighbor_body: str,
|
|
api_key: str) -> dict:
|
|
"""Use Haiku to classify the edge type between two claims.
|
|
|
|
Returns {"edge_type": str, "confidence": float, "reason": str}.
|
|
Falls back to "related" on any failure.
|
|
"""
|
|
default = {"edge_type": "related", "confidence": 0.5, "reason": "classification failed"}
|
|
|
|
prompt = CLASSIFY_PROMPT.format(
|
|
orphan_title=orphan_title,
|
|
orphan_body=orphan_body[:500],
|
|
neighbor_title=neighbor_title,
|
|
neighbor_body=neighbor_body[:500],
|
|
)
|
|
|
|
payload = json.dumps({
|
|
"model": "anthropic/claude-3.5-haiku",
|
|
"messages": [{"role": "user", "content": prompt}],
|
|
"max_tokens": 200,
|
|
"temperature": 0.3,
|
|
}).encode()
|
|
|
|
req = urllib.request.Request(
|
|
"https://openrouter.ai/api/v1/chat/completions",
|
|
data=payload,
|
|
headers={
|
|
"Authorization": f"Bearer {api_key}",
|
|
"Content-Type": "application/json",
|
|
},
|
|
)
|
|
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=15) as resp:
|
|
data = json.loads(resp.read())
|
|
content = data["choices"][0]["message"]["content"].strip()
|
|
|
|
# Parse JSON from response (handle markdown code blocks)
|
|
if content.startswith("```"):
|
|
content = content.split("\n", 1)[-1].rsplit("```", 1)[0].strip()
|
|
|
|
result = json.loads(content)
|
|
edge_type = result.get("edge_type", "related")
|
|
confidence = float(result.get("confidence", 0.5))
|
|
|
|
# Enforce confidence floor for supports/challenges
|
|
if edge_type in ("supports", "challenges") and confidence < HAIKU_CONFIDENCE_FLOOR:
|
|
edge_type = "related"
|
|
|
|
return {
|
|
"edge_type": edge_type,
|
|
"confidence": confidence,
|
|
"reason": result.get("reason", ""),
|
|
}
|
|
except Exception as e:
|
|
logger.warning("Haiku classification failed: %s", e)
|
|
return default
|
|
|
|
|
|
# ─── YAML Frontmatter Editing ────────────────────────────────────────────────
|
|
|
|
|
|
def _count_reweave_edges(path: Path) -> int:
|
|
"""Count existing reweave_edges in a file's frontmatter."""
|
|
fm = _parse_frontmatter(path)
|
|
if not fm:
|
|
return 0
|
|
rw = fm.get("reweave_edges")
|
|
if isinstance(rw, list):
|
|
return len(rw)
|
|
return 0
|
|
|
|
|
|
def write_edge(neighbor_path: Path, orphan_title: str, edge_type: str,
|
|
date_str: str, dry_run: bool = False) -> bool:
|
|
"""Write a reweave edge on the neighbor's frontmatter.
|
|
|
|
Adds to both the edge_type list (related/supports/challenges) and
|
|
the parallel reweave_edges list for provenance tracking.
|
|
|
|
Uses ruamel.yaml for round-trip YAML preservation.
|
|
"""
|
|
# Check per-file cap
|
|
if _count_reweave_edges(neighbor_path) >= PER_FILE_EDGE_CAP:
|
|
logger.info(" Skip %s — per-file edge cap (%d) reached", neighbor_path.name, PER_FILE_EDGE_CAP)
|
|
return False
|
|
|
|
try:
|
|
text = neighbor_path.read_text(errors="replace")
|
|
except Exception as e:
|
|
logger.warning(" Cannot read %s: %s", neighbor_path, e)
|
|
return False
|
|
|
|
if not text.startswith("---"):
|
|
logger.warning(" No frontmatter in %s", neighbor_path.name)
|
|
return False
|
|
|
|
end = text.find("\n---", 3)
|
|
if end == -1:
|
|
return False
|
|
|
|
fm_text = text[3:end]
|
|
body_text = text[end:] # includes the closing ---
|
|
|
|
# Try ruamel.yaml for round-trip editing
|
|
try:
|
|
from ruamel.yaml import YAML
|
|
ry = YAML()
|
|
ry.preserve_quotes = True
|
|
ry.width = 4096 # prevent line wrapping
|
|
|
|
import io
|
|
fm = ry.load(fm_text)
|
|
if not isinstance(fm, dict):
|
|
return False
|
|
|
|
# Add to edge_type list (related/supports/challenges)
|
|
# Clean value only — provenance tracked in reweave_edges (Ganymede: comment-in-string bug)
|
|
if edge_type not in fm:
|
|
fm[edge_type] = []
|
|
elif not isinstance(fm[edge_type], list):
|
|
fm[edge_type] = [fm[edge_type]]
|
|
|
|
# Check for duplicate
|
|
existing = [str(v).strip().lower() for v in fm[edge_type] if v]
|
|
if orphan_title.strip().lower() in existing:
|
|
logger.info(" Skip duplicate edge: %s → %s", neighbor_path.name, orphan_title)
|
|
return False
|
|
|
|
fm[edge_type].append(orphan_title)
|
|
|
|
# Add to reweave_edges with provenance (edge_type + date for audit trail)
|
|
if "reweave_edges" not in fm:
|
|
fm["reweave_edges"] = []
|
|
elif not isinstance(fm["reweave_edges"], list):
|
|
fm["reweave_edges"] = [fm["reweave_edges"]]
|
|
fm["reweave_edges"].append(f"{orphan_title}|{edge_type}|{date_str}")
|
|
|
|
# Serialize back
|
|
buf = io.StringIO()
|
|
ry.dump(fm, buf)
|
|
new_fm = buf.getvalue().rstrip("\n")
|
|
|
|
new_text = f"---\n{new_fm}{body_text}"
|
|
|
|
if not dry_run:
|
|
neighbor_path.write_text(new_text)
|
|
return True
|
|
|
|
except ImportError:
|
|
# Fallback: regex-based editing (no ruamel.yaml installed)
|
|
logger.info(" ruamel.yaml not available, using regex fallback")
|
|
return _write_edge_regex(neighbor_path, fm_text, body_text, orphan_title,
|
|
edge_type, date_str, dry_run)
|
|
|
|
|
|
def _write_edge_regex(neighbor_path: Path, fm_text: str, body_text: str,
|
|
orphan_title: str, edge_type: str, date_str: str,
|
|
dry_run: bool) -> bool:
|
|
"""Fallback: add edge via regex when ruamel.yaml is unavailable."""
|
|
# Strip leading newline from fm_text (text[3:end] includes \n after ---)
|
|
fm_text = fm_text.lstrip("\n")
|
|
|
|
# Check for duplicate before writing
|
|
existing_re = re.compile(
|
|
rf'^\s*-\s*["\']?{re.escape(orphan_title)}["\']?\s*$',
|
|
re.MULTILINE | re.IGNORECASE,
|
|
)
|
|
if existing_re.search(fm_text):
|
|
logger.info(" Skip duplicate edge (regex): %s → %s", neighbor_path.name, orphan_title)
|
|
return False
|
|
|
|
# Check if edge_type field exists
|
|
field_re = re.compile(rf"^{edge_type}:\s*$", re.MULTILINE)
|
|
inline_re = re.compile(rf'^{edge_type}:\s*\[', re.MULTILINE)
|
|
|
|
entry_line = f'- {orphan_title}'
|
|
rw_line = f'- {orphan_title}|{edge_type}|{date_str}'
|
|
|
|
if field_re.search(fm_text):
|
|
# Multi-line list exists — find end of list, append
|
|
lines = fm_text.split("\n")
|
|
new_lines = []
|
|
in_field = False
|
|
inserted = False
|
|
for line in lines:
|
|
new_lines.append(line)
|
|
if re.match(rf"^{edge_type}:\s*$", line):
|
|
in_field = True
|
|
elif in_field and not line.startswith(("- ", " -")):
|
|
# End of list — insert before this line
|
|
new_lines.insert(-1, entry_line)
|
|
in_field = False
|
|
inserted = True
|
|
if in_field and not inserted:
|
|
# Field was last in frontmatter
|
|
new_lines.append(entry_line)
|
|
fm_text = "\n".join(new_lines)
|
|
|
|
elif inline_re.search(fm_text):
|
|
# Inline list — skip, too complex for regex
|
|
logger.warning(" Inline list format for %s in %s, skipping", edge_type, neighbor_path.name)
|
|
return False
|
|
else:
|
|
# Field doesn't exist — add at end of frontmatter
|
|
fm_text = fm_text.rstrip("\n") + f"\n{edge_type}:\n{entry_line}"
|
|
|
|
# Add reweave_edges field
|
|
if "reweave_edges:" in fm_text:
|
|
lines = fm_text.split("\n")
|
|
new_lines = []
|
|
in_rw = False
|
|
inserted_rw = False
|
|
for line in lines:
|
|
new_lines.append(line)
|
|
if re.match(r"^reweave_edges:\s*$", line):
|
|
in_rw = True
|
|
elif in_rw and not line.startswith(("- ", " -")):
|
|
new_lines.insert(-1, rw_line)
|
|
in_rw = False
|
|
inserted_rw = True
|
|
if in_rw and not inserted_rw:
|
|
new_lines.append(rw_line)
|
|
fm_text = "\n".join(new_lines)
|
|
else:
|
|
fm_text = fm_text.rstrip("\n") + f"\nreweave_edges:\n{rw_line}"
|
|
|
|
new_text = f"---\n{fm_text}{body_text}"
|
|
|
|
if not dry_run:
|
|
neighbor_path.write_text(new_text)
|
|
return True
|
|
|
|
|
|
# ─── Git + PR ────────────────────────────────────────────────────────────────
|
|
|
|
|
|
def create_branch(repo_root: Path, branch_name: str) -> bool:
|
|
"""Create and checkout a new branch. Cleans up stale local/remote branches from prior failed runs."""
|
|
# Delete stale local branch if it exists (e.g., from a failed earlier run today)
|
|
subprocess.run(["git", "branch", "-D", branch_name],
|
|
cwd=str(repo_root), capture_output=True) # ignore errors if branch doesn't exist
|
|
|
|
# Delete stale remote branch if it exists
|
|
token_file = SECRETS_DIR / "forgejo-admin-token"
|
|
if token_file.exists():
|
|
token = token_file.read_text().strip()
|
|
push_url = f"http://teleo:{token}@localhost:3000/teleo/teleo-codex.git"
|
|
subprocess.run(["git", "push", push_url, "--delete", branch_name],
|
|
cwd=str(repo_root), capture_output=True) # ignore errors if branch doesn't exist
|
|
|
|
try:
|
|
subprocess.run(["git", "checkout", "-b", branch_name],
|
|
cwd=str(repo_root), check=True, capture_output=True)
|
|
return True
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error("Failed to create branch %s: %s", branch_name, e.stderr.decode())
|
|
return False
|
|
|
|
|
|
def commit_and_push(repo_root: Path, branch_name: str, modified_files: list[Path],
|
|
orphan_count: int) -> bool:
|
|
"""Stage modified files, commit, and push."""
|
|
# Stage only modified files
|
|
for f in modified_files:
|
|
subprocess.run(["git", "add", str(f)], cwd=str(repo_root),
|
|
check=True, capture_output=True)
|
|
|
|
# Check if anything staged
|
|
result = subprocess.run(["git", "diff", "--cached", "--name-only"],
|
|
cwd=str(repo_root), capture_output=True, text=True)
|
|
if not result.stdout.strip():
|
|
logger.info("No files staged — nothing to commit")
|
|
return False
|
|
|
|
msg = (
|
|
f"reweave: connect {orphan_count} orphan claims via vector similarity\n\n"
|
|
f"Threshold: {DEFAULT_THRESHOLD}, Haiku classification, {len(modified_files)} files modified.\n\n"
|
|
f"Pentagon-Agent: Epimetheus <0144398e-4ed3-4fe2-95a3-3d72e1abf887>"
|
|
)
|
|
subprocess.run(["git", "commit", "-m", msg], cwd=str(repo_root),
|
|
check=True, capture_output=True)
|
|
|
|
# Push — inject token
|
|
token_file = SECRETS_DIR / "forgejo-admin-token"
|
|
if not token_file.exists():
|
|
logger.error("No Forgejo token found at %s", token_file)
|
|
return False
|
|
token = token_file.read_text().strip()
|
|
push_url = f"http://teleo:{token}@localhost:3000/teleo/teleo-codex.git"
|
|
|
|
subprocess.run(["git", "push", "-u", push_url, branch_name],
|
|
cwd=str(repo_root), check=True, capture_output=True)
|
|
return True
|
|
|
|
|
|
def create_pr(branch_name: str, orphan_count: int, summary_lines: list[str]) -> str | None:
|
|
"""Create a Forgejo PR for the reweave batch."""
|
|
token_file = SECRETS_DIR / "forgejo-admin-token"
|
|
if not token_file.exists():
|
|
return None
|
|
token = token_file.read_text().strip()
|
|
|
|
summary = "\n".join(f"- {line}" for line in summary_lines[:30])
|
|
body = (
|
|
f"## Orphan Reweave\n\n"
|
|
f"Connected **{orphan_count}** orphan claims to the knowledge graph "
|
|
f"via vector similarity (threshold {DEFAULT_THRESHOLD}) + Haiku edge classification.\n\n"
|
|
f"### Edges Added\n{summary}\n\n"
|
|
f"### Review Guide\n"
|
|
f"- Each edge has a `# reweave:YYYY-MM-DD` comment — strip after review\n"
|
|
f"- `reweave_edges` field tracks automated edges for tooling (graph_expand weights them 0.75x)\n"
|
|
f"- Upgrade `related` → `supports`/`challenges` where you have better judgment\n"
|
|
f"- Delete any edges that don't make sense\n\n"
|
|
f"Pentagon-Agent: Epimetheus"
|
|
)
|
|
|
|
payload = json.dumps({
|
|
"title": f"reweave: connect {orphan_count} orphan claims",
|
|
"body": body,
|
|
"head": branch_name,
|
|
"base": "main",
|
|
}).encode()
|
|
|
|
req = urllib.request.Request(
|
|
f"{FORGEJO_URL}/api/v1/repos/teleo/teleo-codex/pulls",
|
|
data=payload,
|
|
headers={
|
|
"Authorization": f"token {token}",
|
|
"Content-Type": "application/json",
|
|
},
|
|
)
|
|
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=30) as resp:
|
|
data = json.loads(resp.read())
|
|
return data.get("html_url", "")
|
|
except Exception as e:
|
|
logger.error("PR creation failed: %s", e)
|
|
return None
|
|
|
|
|
|
# ─── Worktree Lock ───────────────────────────────────────────────────────────
|
|
|
|
_lock_fd = None # Module-level to prevent GC and avoid function-attribute fragility
|
|
|
|
|
|
def acquire_lock(lock_path: Path, timeout: int = 30) -> bool:
|
|
"""Acquire file lock for worktree access. Returns True if acquired."""
|
|
global _lock_fd
|
|
import fcntl
|
|
try:
|
|
lock_path.parent.mkdir(parents=True, exist_ok=True)
|
|
_lock_fd = open(lock_path, "w")
|
|
fcntl.flock(_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
_lock_fd.write(f"reweave:{os.getpid()}\n")
|
|
_lock_fd.flush()
|
|
return True
|
|
except (IOError, OSError):
|
|
logger.warning("Could not acquire worktree lock at %s — another process has it", lock_path)
|
|
_lock_fd = None
|
|
return False
|
|
|
|
|
|
def release_lock(lock_path: Path):
|
|
"""Release worktree lock."""
|
|
global _lock_fd
|
|
import fcntl
|
|
fd = _lock_fd
|
|
_lock_fd = None
|
|
if fd:
|
|
try:
|
|
fcntl.flock(fd, fcntl.LOCK_UN)
|
|
fd.close()
|
|
except Exception:
|
|
pass
|
|
try:
|
|
lock_path.unlink(missing_ok=True)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
# ─── Main ────────────────────────────────────────────────────────────────────
|
|
|
|
|
|
def main():
|
|
global REPO_DIR, DEFAULT_THRESHOLD
|
|
|
|
parser = argparse.ArgumentParser(description="Orphan Reweave — connect isolated claims")
|
|
parser.add_argument("--dry-run", action="store_true",
|
|
help="Show what would be connected without modifying files")
|
|
parser.add_argument("--max-orphans", type=int, default=DEFAULT_MAX_ORPHANS,
|
|
help=f"Max orphans to process (default {DEFAULT_MAX_ORPHANS})")
|
|
parser.add_argument("--max-neighbors", type=int, default=DEFAULT_MAX_NEIGHBORS,
|
|
help=f"Max neighbors per orphan (default {DEFAULT_MAX_NEIGHBORS})")
|
|
parser.add_argument("--threshold", type=float, default=DEFAULT_THRESHOLD,
|
|
help=f"Minimum cosine similarity (default {DEFAULT_THRESHOLD})")
|
|
parser.add_argument("--repo-dir", type=str, default=None,
|
|
help="Override repo directory")
|
|
args = parser.parse_args()
|
|
|
|
if args.repo_dir:
|
|
REPO_DIR = Path(args.repo_dir)
|
|
DEFAULT_THRESHOLD = args.threshold
|
|
|
|
date_str = datetime.date.today().isoformat()
|
|
branch_name = f"reweave/{date_str}"
|
|
|
|
logger.info("=== Orphan Reweave ===")
|
|
logger.info("Repo: %s", REPO_DIR)
|
|
logger.info("Threshold: %.2f, Max orphans: %d, Max neighbors: %d",
|
|
args.threshold, args.max_orphans, args.max_neighbors)
|
|
if args.dry_run:
|
|
logger.info("DRY RUN — no files will be modified")
|
|
|
|
# Step 1: Find all claims and build reverse-link index
|
|
logger.info("Step 1: Scanning KB for claims...")
|
|
claims = find_all_claims(REPO_DIR)
|
|
logger.info(" Found %d knowledge files", len(claims))
|
|
|
|
logger.info("Step 2: Building reverse-link index...")
|
|
incoming = build_reverse_link_index(claims)
|
|
|
|
logger.info("Step 3: Finding orphans...")
|
|
orphans = find_orphans(claims, incoming, REPO_DIR)
|
|
orphans = sort_orphans_by_domain(orphans, REPO_DIR)
|
|
logger.info(" Found %d orphans (%.1f%% of %d claims)",
|
|
len(orphans), 100 * len(orphans) / max(len(claims), 1), len(claims))
|
|
|
|
if not orphans:
|
|
logger.info("No orphans found — KB is fully connected!")
|
|
return
|
|
|
|
# Cap to max_orphans
|
|
batch = orphans[:args.max_orphans]
|
|
logger.info(" Processing batch of %d orphans", len(batch))
|
|
|
|
# Step 4: For each orphan, find neighbors and classify edges
|
|
api_key = _get_api_key()
|
|
edges_to_write: list[dict] = [] # {neighbor_path, orphan_title, edge_type, reason, score}
|
|
skipped_no_vector = 0
|
|
skipped_no_neighbors = 0
|
|
skipped_entity_pair = 0
|
|
skipped_same_source = 0
|
|
|
|
for i, orphan_path in enumerate(batch):
|
|
rel_path = str(orphan_path.relative_to(REPO_DIR))
|
|
fm = _parse_frontmatter(orphan_path)
|
|
orphan_title = fm.get("name", fm.get("title", orphan_path.stem.replace("-", " "))) if fm else orphan_path.stem
|
|
orphan_body = _get_body(orphan_path)
|
|
|
|
logger.info("[%d/%d] %s", i + 1, len(batch), orphan_title[:80])
|
|
|
|
# Get vector from Qdrant
|
|
vector = get_vector_from_qdrant(rel_path)
|
|
if not vector:
|
|
logger.info(" No vector in Qdrant — skipping (not embedded yet)")
|
|
skipped_no_vector += 1
|
|
continue
|
|
|
|
# Find neighbors
|
|
hits = search_neighbors(vector, rel_path, args.threshold, args.max_neighbors)
|
|
if not hits:
|
|
logger.info(" No neighbors above threshold %.2f", args.threshold)
|
|
skipped_no_neighbors += 1
|
|
continue
|
|
|
|
for hit in hits:
|
|
payload = hit.get("payload", {})
|
|
neighbor_rel = payload.get("claim_path", "")
|
|
neighbor_title = payload.get("claim_title", "")
|
|
score = hit.get("score", 0)
|
|
|
|
if not neighbor_rel:
|
|
continue
|
|
|
|
neighbor_path = REPO_DIR / neighbor_rel
|
|
if not neighbor_path.exists():
|
|
logger.info(" Neighbor %s not found on disk — skipping", neighbor_rel)
|
|
continue
|
|
|
|
# Entity-to-entity exclusion: entities need different vocabulary
|
|
# (founded_by, competes_with, etc.) not supports/challenges
|
|
if _is_entity(orphan_path) and _is_entity(neighbor_path):
|
|
logger.info(" Skip entity-entity pair: %s ↔ %s", orphan_path.name, neighbor_path.name)
|
|
skipped_entity_pair += 1
|
|
continue
|
|
|
|
# Same-source exclusion: N claims from one paper all "supporting" each other
|
|
# inflates graph density without adding information
|
|
if _same_source(orphan_path, neighbor_path):
|
|
logger.info(" Skip same-source pair: %s ↔ %s", orphan_path.name, neighbor_path.name)
|
|
skipped_same_source += 1
|
|
continue
|
|
|
|
neighbor_body = _get_body(neighbor_path)
|
|
|
|
# Classify with Haiku
|
|
result = classify_edge(orphan_title, orphan_body,
|
|
neighbor_title, neighbor_body, api_key)
|
|
edge_type = result["edge_type"]
|
|
confidence = result["confidence"]
|
|
reason = result["reason"]
|
|
|
|
logger.info(" → %s (%.3f) %s [%.2f]: %s",
|
|
neighbor_title[:50], score, edge_type, confidence, reason[:60])
|
|
|
|
edges_to_write.append({
|
|
"neighbor_path": neighbor_path,
|
|
"neighbor_rel": neighbor_rel,
|
|
"neighbor_title": neighbor_title,
|
|
"orphan_title": str(orphan_title),
|
|
"orphan_rel": rel_path,
|
|
"edge_type": edge_type,
|
|
"score": score,
|
|
"confidence": confidence,
|
|
"reason": reason,
|
|
})
|
|
|
|
# Rate limit courtesy
|
|
if not args.dry_run and i < len(batch) - 1:
|
|
time.sleep(0.3)
|
|
|
|
logger.info("\n=== Summary ===")
|
|
logger.info("Orphans processed: %d", len(batch))
|
|
logger.info("Edges to write: %d", len(edges_to_write))
|
|
logger.info("Skipped (no vector): %d", skipped_no_vector)
|
|
logger.info("Skipped (no neighbors): %d", skipped_no_neighbors)
|
|
logger.info("Skipped (entity-entity): %d", skipped_entity_pair)
|
|
logger.info("Skipped (same-source): %d", skipped_same_source)
|
|
|
|
if not edges_to_write:
|
|
logger.info("Nothing to write.")
|
|
return
|
|
|
|
if args.dry_run:
|
|
logger.info("\n=== Dry Run — Edges That Would Be Written ===")
|
|
for e in edges_to_write:
|
|
logger.info(" %s → [%s] → %s (score=%.3f, conf=%.2f)",
|
|
e["neighbor_title"][:40], e["edge_type"],
|
|
e["orphan_title"][:40], e["score"], e["confidence"])
|
|
return
|
|
|
|
# Step 5: Acquire lock, create branch, write edges, commit, push, create PR
|
|
lock_path = REPO_DIR.parent / ".main-worktree.lock"
|
|
if not acquire_lock(lock_path):
|
|
logger.error("Cannot acquire worktree lock — aborting")
|
|
sys.exit(1)
|
|
|
|
try:
|
|
# Create branch
|
|
if not create_branch(REPO_DIR, branch_name):
|
|
logger.error("Failed to create branch %s", branch_name)
|
|
sys.exit(1)
|
|
|
|
# Write edges
|
|
modified_files = set()
|
|
written = 0
|
|
summary_lines = []
|
|
|
|
for e in edges_to_write:
|
|
ok = write_edge(
|
|
e["neighbor_path"], e["orphan_title"], e["edge_type"],
|
|
date_str, dry_run=False,
|
|
)
|
|
if ok:
|
|
modified_files.add(e["neighbor_path"])
|
|
written += 1
|
|
summary_lines.append(
|
|
f"`{e['neighbor_title'][:50]}` → [{e['edge_type']}] → "
|
|
f"`{e['orphan_title'][:50]}` (score={e['score']:.3f})"
|
|
)
|
|
|
|
logger.info("Wrote %d edges across %d files", written, len(modified_files))
|
|
|
|
if not modified_files:
|
|
logger.info("No edges written — cleaning up branch")
|
|
subprocess.run(["git", "checkout", "main"], cwd=str(REPO_DIR),
|
|
capture_output=True)
|
|
subprocess.run(["git", "branch", "-d", branch_name], cwd=str(REPO_DIR),
|
|
capture_output=True)
|
|
return
|
|
|
|
# Commit and push
|
|
orphan_count = len(set(e["orphan_title"] for e in edges_to_write if e["neighbor_path"] in modified_files))
|
|
if commit_and_push(REPO_DIR, branch_name, list(modified_files), orphan_count):
|
|
logger.info("Pushed branch %s", branch_name)
|
|
|
|
# Create PR
|
|
pr_url = create_pr(branch_name, orphan_count, summary_lines)
|
|
if pr_url:
|
|
logger.info("PR created: %s", pr_url)
|
|
else:
|
|
logger.warning("PR creation failed — branch is pushed, create manually")
|
|
else:
|
|
logger.error("Commit/push failed")
|
|
|
|
finally:
|
|
# Always return to main — even on exception (Ganymede: branch cleanup)
|
|
try:
|
|
subprocess.run(["git", "checkout", "main"], cwd=str(REPO_DIR),
|
|
capture_output=True)
|
|
except Exception:
|
|
pass
|
|
release_lock(lock_path)
|
|
|
|
logger.info("Done.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|