@heretek-ai/epistemic-swarm 0.7.0 → 0.7.2

package/skills/darkharvest/scripts/harvest.py

@@ -59,11 +59,19 @@ TEXT_EXTS = {".md", ".json", ".toml", ".yaml", ".yml", ".txt", ".py", ".js", ".t
 DEFAULT_MAX_FILES = 120
 DEFAULT_MAX_BYTES = 400_000
 DEFAULT_TIMEOUT = 120
+DEFAULT_BASE_DIR = ".research"
+MAX_SCAN_DEPTH = 3
+MAX_SINGLE_FILE_BYTES = 100_000
+SNIPPET_CHARS = 4000
+
+SPDX_APACHE2 = "Apache-2.0"
+PERMISSIVE_SPDX = frozenset({"MIT", SPDX_APACHE2, "BSD-3-Clause", "ISC"})
+COPYLEFT_SPDX = frozenset({"GPL", "AGPL"})
 
 SPDX_MAP = {
     "mit": "MIT",
-    "apache-2.0": "Apache-2.0",
-    "apache 2.0": "Apache-2.0",
+    "apache-2.0": SPDX_APACHE2,
+    "apache 2.0": SPDX_APACHE2,
     "bsd-3-clause": "BSD-3-Clause",
     "bsd 3-clause": "BSD-3-Clause",
     "isc": "ISC",
@@ -97,43 +105,74 @@ def detect_license(text):
 
 
 def scan_tree(root, max_files=DEFAULT_MAX_FILES, max_bytes=DEFAULT_MAX_BYTES):
-    entries = []
-    total_bytes = 0
-    manifests = {}
-    license_text = ""
-    readme_head = ""
+    root = Path(root)
+    state = _ScanState()
     for dirpath, dirnames, filenames in os.walk(root):
         dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
         rel = Path(dirpath).relative_to(root)
-        depth = len(rel.parts) if str(rel) != "." else 0
-        if depth > 3:
+        if (len(rel.parts) if str(rel) != "." else 0) > MAX_SCAN_DEPTH:
             dirnames[:] = []
             continue
+        prefix = "" if str(rel) == "." else str(rel) + os.sep
         for f in sorted(filenames):
-            if len(entries) >= max_files or total_bytes >= max_bytes:
-                return entries, manifests, license_text, readme_head, True
-            fp = Path(dirpath) / f
-            try:
-                size = fp.stat().st_size
-            except OSError:
-                continue
-            if size > 100_000:
-                continue
-            rel_p = str(rel / f) if str(rel) != "." else f
-            entries.append(rel_p)
-            if f in MANIFEST_FILES or Path(f).suffix in TEXT_EXTS:
-                try:
-                    content = fp.read_text(encoding="utf-8", errors="replace")
-                except OSError:
-                    continue
-                total_bytes += len(content.encode("utf-8", errors="replace"))
-                if f in MANIFEST_FILES and f not in manifests:
-                    manifests[f] = content[:4000]
-                if f.lower().startswith("license") and not license_text:
-                    license_text = content[:4000]
-                if f.lower() == "readme.md" and not readme_head:
-                    readme_head = content[:4000]
-    return entries, manifests, license_text, readme_head, False
+            if state.capped(max_files, max_bytes):
+                return state.finish(truncated=True)
+            _scan_file(dirpath, prefix + f, state)
+    return state.finish(truncated=False)
+
+
+class _ScanState:
+    """Mutable accumulator for one scan_tree pass (keeps helpers small)."""
+
+    def __init__(self):
+        self.entries = []
+        self.total_bytes = 0
+        self.manifests = {}
+        self.license_text = ""
+        self.readme_head = ""
+
+    def capped(self, max_files, max_bytes):
+        return len(self.entries) >= max_files or self.total_bytes >= max_bytes
+
+    def finish(self, truncated):
+        return (
+            self.entries,
+            self.manifests,
+            self.license_text,
+            self.readme_head,
+            truncated,
+        )
+
+
+def _scan_file(dirpath, rel_entry, state):
+    filename = os.path.basename(rel_entry)
+    try:
+        size = (Path(dirpath) / filename).stat().st_size
+    except OSError:
+        return
+    if size > MAX_SINGLE_FILE_BYTES:
+        return
+    state.entries.append(rel_entry)
+    if filename in MANIFEST_FILES or Path(filename).suffix in TEXT_EXTS:
+        _capture_text(dirpath, filename, state)
+
+
+def _capture_text(dirpath, filename, state):
+    try:
+        content = (Path(dirpath) / filename).read_text(
+            encoding="utf-8", errors="replace"
+        )
+    except OSError:
+        return
+    state.total_bytes += len(content.encode("utf-8", errors="replace"))
+    snippet = content[:SNIPPET_CHARS]
+    if filename in MANIFEST_FILES and filename not in state.manifests:
+        state.manifests[filename] = snippet
+    lowered = filename.lower()
+    if lowered.startswith("license") and not state.license_text:
+        state.license_text = snippet
+    if lowered == "readme.md" and not state.readme_head:
+        state.readme_head = snippet
 
 
 def harvest_repo(
@@ -141,7 +180,7 @@ def harvest_repo(
     max_files=DEFAULT_MAX_FILES,
     max_bytes=DEFAULT_MAX_BYTES,
     timeout=DEFAULT_TIMEOUT,
-    base_dir=".research",
+    base_dir=DEFAULT_BASE_DIR,
 ):
     started = datetime.now(timezone.utc).isoformat()
     tmp = tempfile.mkdtemp(prefix="darkharvest-")
@@ -162,9 +201,7 @@ def harvest_repo(
         )
         spdx = detect_license(license_text + manifests.get("package.json", ""))
         harvestable = (
-            "depend-or-vendor"
-            if spdx in ("MIT", "Apache-2.0", "BSD-3-Clause", "ISC")
-            else "clean-room-rebuild-only"
+            "depend-or-vendor" if spdx in PERMISSIVE_SPDX else "clean-room-rebuild-only"
         )
         hasher = SourceHasher(Path(base_dir))
         cache_blob = (
@@ -174,7 +211,7 @@ def harvest_repo(
         )
         source_hash = hasher.store_source(url, cache_blob, f"Darkharvest {url}")
         warnings = []
-        if spdx in ("GPL", "AGPL"):
+        if spdx in COPYLEFT_SPDX:
             warnings.append(
                 "⚠️ LICENSE: strong copyleft — spec rebuild only, never vendor"
             )
@@ -209,7 +246,7 @@ def main():
     ap.add_argument("--max-files", type=int, default=DEFAULT_MAX_FILES)
     ap.add_argument("--max-bytes", type=int, default=DEFAULT_MAX_BYTES)
     ap.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT)
-    ap.add_argument("--dir", default=".research")
+    ap.add_argument("--dir", default=DEFAULT_BASE_DIR)
     args = ap.parse_args()
 
     if not re.match(r"^https?://", args.repo):

package/skills/epistemic_search/scripts/search.py

@@ -79,11 +79,9 @@ class DDGLiteParser(HTMLParser):
             self._row_snippet = []
 
     def handle_endtag(self, tag: str):
-        if self._capture == "title" and tag == "a":
-            self._depth -= 1
-            if self._depth <= 0:
-                self._capture = None
-        elif self._capture == "snippet" and tag == "td":
+        if (self._capture == "title" and tag == "a") or (
+            self._capture == "snippet" and tag == "td"
+        ):
             self._depth -= 1
             if self._depth <= 0:
                 self._capture = None
@@ -99,11 +97,13 @@ class DDGLiteParser(HTMLParser):
     def flush(self):
         """Emit the in-progress row, if any. Call after ``feed()`` completes."""
         if self._row_href is not None:
-            self.results.append({
-                "href": self._row_href,
-                "title": "".join(self._row_title).strip(),
-                "snippet": "".join(self._row_snippet).strip(),
-            })
+            self.results.append(
+                {
+                    "href": self._row_href,
+                    "title": "".join(self._row_title).strip(),
+                    "snippet": "".join(self._row_snippet).strip(),
+                }
+            )
         self._row_href = None
         self._row_title = []
         self._row_snippet = []
@@ -138,7 +138,9 @@ def _fetch_ddg_html(effective_query: str) -> str:
         with urllib.request.urlopen(req, timeout=15) as resp:
             return resp.read().decode("utf-8", errors="replace")
     except Exception as e:
-        sys.stderr.write(f"[epistemic-search] Network error fetching search results: {e}\n")
+        sys.stderr.write(
+            f"[epistemic-search] Network error fetching search results: {e}\n"
+        )
         return ""
 
 
@@ -154,9 +156,13 @@ def _is_domain_allowed(
     allowed_domains: Optional[List[str]] = None,
     blocked_domains: Optional[List[str]] = None,
 ) -> bool:
-    if allowed_domains and not any(hostname == d or hostname.endswith("." + d) for d in allowed_domains):
+    if allowed_domains and not any(
+        hostname == d or hostname.endswith("." + d) for d in allowed_domains
+    ):
         return False
-    if blocked_domains and any(hostname == d or hostname.endswith("." + d) for d in blocked_domains):
+    if blocked_domains and any(
+        hostname == d or hostname.endswith("." + d) for d in blocked_domains
+    ):
         return False
     return True
 
@@ -188,11 +194,13 @@ def search_duckduckgo(
         if not _is_domain_allowed(hostname, allowed_domains, blocked_domains):
             continue
 
-        results.append({
-            "title": row["title"],
-            "url": clean_url,
-            "snippet": row["snippet"],
-        })
+        results.append(
+            {
+                "title": row["title"],
+                "url": clean_url,
+                "snippet": row["snippet"],
+            }
+        )
         if len(results) >= max_results:
             break
 
@@ -272,7 +280,9 @@ def main():
     )
 
     if not query:
-        sys.stderr.write("Usage: search.py [options] <query>\nOr pipe JSON: echo '{\"query\":\"...\"}' | search.py\n")
+        sys.stderr.write(
+            'Usage: search.py [options] <query>\nOr pipe JSON: echo \'{"query":"..."}\' | search.py\n'
+        )
         sys.exit(1)
 
     results = search_duckduckgo(

package/skills/epistemic_search/scripts/webcache.py

@@ -60,7 +60,9 @@ def canonical_url(url):
         query = urllib.parse.urlencode(
             sorted(urllib.parse.parse_qsl(p.query, keep_blank_values=True))
         )
-        return urllib.parse.urlunsplit((p.scheme or "https", netloc, p.path or "/", query, ""))
+        return urllib.parse.urlunsplit(
+            (p.scheme or "https", netloc, p.path or "/", query, "")
+        )
     except Exception:
         return None
 
@@ -142,7 +144,9 @@ def cmd_gate(stdin_data):
         return None  # miss -> allow, PostToolUse archives
     md_path, meta = found
     if not is_fresh(meta, url):
-        log(f"stale entry for {domain_of(url)} ({meta.get('cached_at')}); allowing live fetch")
+        log(
+            f"stale entry for {domain_of(url)} ({meta.get('cached_at')}); allowing live fetch"
+        )
         return None  # stale -> allow, PostToolUse refreshes
     try:
         content = md_path.read_text(encoding="utf-8")
@@ -174,24 +178,32 @@ def cmd_gate(stdin_data):
     }
 
 
+def _text_from_value(val):
+    """Recursively pull the first non-empty text out of a response value."""
+    if isinstance(val, str) and val.strip():
+        return val
+    if isinstance(val, dict):
+        for sub in ("text", "content", "output"):
+            got = _text_from_value(val.get(sub))
+            if got:
+                return got
+    if isinstance(val, list):
+        parts = [
+            p.get("text", "")
+            for p in val
+            if isinstance(p, dict) and isinstance(p.get("text"), str)
+        ]
+        if parts:
+            return "\n".join(parts)
+    return ""
+
+
 def extract_response_text(stdin_data):
     """Defensively locate the tool response text across field-name variants."""
     for key in ("tool_response", "response", "tool_result", "result", "output"):
-        val = stdin_data.get(key)
-        if isinstance(val, str) and val.strip():
-            return val
-        if isinstance(val, dict):
-            for sub in ("text", "content", "output"):
-                inner = val.get(sub)
-                if isinstance(inner, str) and inner.strip():
-                    return inner
-                if isinstance(inner, list):
-                    parts = [
-                        p.get("text", "") for p in inner
-                        if isinstance(p, dict) and isinstance(p.get("text"), str)
-                    ]
-                    if parts:
-                        return "\n".join(parts)
+        got = _text_from_value(stdin_data.get(key))
+        if got:
+            return got
     return ""
 
 

package/skills/factory/scripts/factory.py

@@ -150,7 +150,7 @@ def cmd_expansion(args):
     state["expansion"]["loops_planned"] = n
     save_state(args.run, state)
     done = 0
-    for i in range(1, n + 1):
+    for _ in range(1, n + 1):
         if stop_requested(args.run):
             print(f"🛑 STOP file present — halting after {done}/{n} loops.")
             break

package/skills/swarm_config/configure.py

@@ -17,6 +17,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
     "max_iterations": 2,
     "divergence_threshold": 0.75,
     "mode": "research",  # "research", "audit", "scout", "hybrid", "brainstorm", "darkharvest"
+    "backend": "auto",  # "auto" (host-native) | "claude" | "opencode"
     "cache_raw_markdown": True,
     "license_whitelist": ["MIT", "Apache-2.0", "BSD-3-Clause", "ISC"],
     "output_dir": DEFAULT_RESEARCH_DIR,
@@ -31,10 +32,12 @@ DEFAULT_CONFIG: Dict[str, Any] = {
     # different model families/weights probe divergence that prompt-level
     # red-teaming cannot reach. `backend` is a command list, not just a model
     # string, because cross-FAMILY means non-Claude processes.
+    # None means "fall through to the host-native default" (claude -p on
+    # Claude Code, opencode run on OpenCode) — explicit values still win.
     # mock mode never builds or spawns these commands.
     "agents": {
-        "alpha": {"backend": ["claude", "-p"], "model": None},
-        "beta": {"backend": ["claude", "-p"], "model": None},
+        "alpha": {"backend": None, "model": None},
+        "beta": {"backend": None, "model": None},
     },
 }
 
@@ -78,6 +81,9 @@ def display_config(cfg: Dict[str, Any]):
     print(f"  🔄 Max Iterations (Depth): {cfg.get('max_iterations', 2)}")
     print(f"  ⚖️  Divergence Threshold:  {cfg.get('divergence_threshold', 0.75)}")
     print(f"  🎯 Operating Mode:         {cfg.get('mode', 'research').upper()}")
+    print(
+        f"  🖥️  Agent Backend:         {cfg.get('backend', 'auto').upper()} (auto = host-native)"
+    )
     print(
         f"  💾 Raw Markdown Caching:   {'ENABLED' if cfg.get('cache_raw_markdown', True) else 'DISABLED'}"
     )
@@ -141,44 +147,71 @@ def run_interactive(cfg: Dict[str, Any]) -> Dict[str, Any]:
     return cfg
 
 
+def _set_engine(cfg, value):
+    if value.lower() in ("duckduckgo", "brave", "firecrawl", "searxng"):
+        cfg["search_engine"] = value.lower()
+        return True
+    return False
+
+
+def _set_depth(cfg, value):
+    try:
+        cfg["max_iterations"] = int(value)
+        return True
+    except ValueError:
+        return False
+
+
+def _set_mode(cfg, value):
+    if value.lower() in (
+        "research",
+        "audit",
+        "scout",
+        "hybrid",
+        "brainstorm",
+        "darkharvest",
+    ):
+        cfg["mode"] = value.lower()
+        return True
+    return False
+
+
+def _set_divergence(cfg, value):
+    try:
+        cfg["divergence_threshold"] = float(value)
+        return True
+    except ValueError:
+        return False
+
+
+def _set_backend(cfg, value):
+    if value.lower() in ("auto", "claude", "opencode"):
+        cfg["backend"] = value.lower()
+        return True
+    return False
+
+
+# flag spellings -> setter; each setter returns True when it changed config.
+_CLI_HANDLERS = [
+    (("--engine", "-e"), _set_engine),
+    (("--depth", "-d", "--iterations"), _set_depth),
+    (("--mode", "-m"), _set_mode),
+    (("--divergence",), _set_divergence),
+    (("--backend",), _set_backend),
+]
+
+
 def _parse_cli_updates(args: list, cfg: Dict[str, Any]) -> bool:
-    idx = 0
     modified = False
+    idx = 0
     while idx < len(args):
-        arg = args[idx]
-        if arg in ("--engine", "-e") and idx + 1 < len(args):
-            engine = args[idx + 1].lower()
-            if engine in ("duckduckgo", "brave", "firecrawl", "searxng"):
-                cfg["search_engine"] = engine
-                modified = True
-            idx += 1
-        elif arg in ("--depth", "-d", "--iterations") and idx + 1 < len(args):
-            try:
-                cfg["max_iterations"] = int(args[idx + 1])
-                modified = True
-            except ValueError:
-                pass
-            idx += 1
-        elif arg in ("--mode", "-m") and idx + 1 < len(args):
-            mode = args[idx + 1].lower()
-            if mode in (
-                "research",
-                "audit",
-                "scout",
-                "hybrid",
-                "brainstorm",
-                "darkharvest",
-            ):
-                cfg["mode"] = mode
-                modified = True
-            idx += 1
-        elif arg == "--divergence" and idx + 1 < len(args):
-            try:
-                cfg["divergence_threshold"] = float(args[idx + 1])
-                modified = True
-            except ValueError:
-                pass
-            idx += 1
+        value = args[idx + 1] if idx + 1 < len(args) else None
+        for flags, handler in _CLI_HANDLERS:
+            if args[idx] in flags:
+                if value is not None and handler(cfg, value):
+                    modified = True
+                idx += 1
+                break
         idx += 1
     return modified