@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/smidja-factory/apps/visualizer/server/model-catalog.ts

@@ -0,0 +1,90 @@
+/**
+ * Model catalog — the machine's pi-resolvable models, shared by every surface
+ * that spawns pi (orchestrator chat, future pickers).
+ *
+ * There are two registries in the smidja:
+ *   1. ROSTER models (roster.yaml)  — what smidja RUNS use for each agent role
+ *   2. PI catalog (`pi --list-models`) — what this machine's pi can actually
+ *      RESOLVE (providers the user has configured: lmstudio, opencode-go, ...)
+ *
+ * They differ (a roster id like `lmstudio/qwen3.5-9b` may not exist in the
+ * machine's pi catalog, which is exactly the "Model not found" chat failure).
+ * So: the CHAT picker shows the pi catalog; roster lists gain an `available`
+ * flag by matching against it. One module, cached, used everywhere.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export interface PiModel {
+  id: string;       // provider/name — what pi resolves
+  name: string;
+  provider: string;
+}
+
+const CACHE_TTL_MS = 60_000;
+let cache: { at: number; cwd: string; models: PiModel[] } | null = null;
+
+/**
+ * Cross-platform `pi` invocation. pi installs as a .cmd shim on Windows
+ * (npm) and a shell binary on macOS/Linux/WSL, so we route Windows through
+ * `cmd /c` and the rest directly. Bun.spawn resolves PATH for both.
+ * For calls that carry free text (chat prompts) the args array is passed
+ * through cmd's command-line builder, which quotes them safely.
+ */
+export function piCommand(args: string[]): string[] {
+  return process.platform === "win32"
+    ? ["cmd", "/c", "pi", ...args]
+    : ["pi", ...args];
+}
+
+/** Shell `pi --list-models` (in the repo root) and normalize to {provider/name}. */
+export async function piModels(cwd: string): Promise<PiModel[]> {
+  if (cache && Date.now() - cache.at < CACHE_TTL_MS && cache.cwd === cwd) {
+    return cache.models;
+  }
+  let models: PiModel[] = [];
+  try {
+    const proc = Bun.spawn(piCommand(["--list-models"]), {
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd,
+      env: { ...(Bun.env as Record<string, string>) },
+    });
+    const out = await new Response(proc.stdout).text();
+    for (const line of out.split(/\r?\n/)) {
+      const cols = line.trim().split(/\s+/);
+      if (cols.length < 2) continue;
+      if (cols[0].startsWith("[") || /^provider$/i.test(cols[0])) continue;
+      const provider = cols[0];
+      const name = cols[1];
+      if (!/^[A-Za-z0-9._-]+$/.test(provider) || !/^[A-Za-z0-9._/:@-]+$/.test(name)) continue;
+      models.push({ id: `${provider}/${name}`, name, provider });
+    }
+    // Dedup (a model can repeat across runs) + stable sort.
+    const seen = new Set<string>();
+    models = models.filter((m) => (seen.has(m.id) ? false : (seen.add(m.id), true)));
+    models.sort((a, b) => a.provider.localeCompare(b.provider) || a.name.localeCompare(b.name));
+  } catch {
+    models = [];
+  }
+  cache = { at: Date.now(), cwd, models };
+  return models;
+}
+
+/**
+ * True when the roster model id exists in the machine's pi catalog (i.e. the
+ * chat / any pi spawn can run it). Match on the exact "provider/name" id.
+ */
+export function isPiResolvable(id: string, catalog: PiModel[]): boolean {
+  return catalog.some((m) => m.id === id);
+}
+
+/** Cache-bust for tests / model installation. */
+export function resetPiModelCache(): void {
+  cache = null;
+}
+
+/** The repo .env (for parity with settings.ts); unused placeholder removed at
+ * next sweep — kept for importing existsSync/join in this module's future use. */
+void existsSync;
+void join;

package/apps/smidja-factory/apps/visualizer/server/roster-api.ts

@@ -0,0 +1,75 @@
+/**
+ * GET /api/rosters, /api/rosters/:name, /api/models — the team & model picker
+ * data for the orchestrator chat.
+ *
+ * Resolves the target repo's roster.yaml by shelling out to the companion
+ * Python helper (server/roster_resolve.py), which mirrors scripts/resolve-config.py's
+ * exact per-role model resolution. We shell out (not a YAML parser in TS) so the
+ * picker always reflects what a real `smidja run` would use, with no duplicated
+ * resolution logic and no extra dependency.
+ *
+ * The result is cached per repo-root for a short window; roster.yaml changes are
+ * rare and the picker is not latency-critical, but we don't want to spawn python
+ * on every keystroke either.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { repoRootOf as repoRoot } from "./db.ts";
+import type { ModelInfo, RosterInfo, RostersResponse, ModelsResponse } from "../shared/types.ts";
+
+/** Where the python helper lives, relative to this server dir. */
+function helperPath(): string {
+  return join(import.meta.dir, "roster_resolve.py");
+}
+
+interface ResolvedPayload {
+  rosters: RosterInfo[];
+  models: ModelInfo[];
+}
+
+const cache = new Map<string, { ts: number; data: ResolvedPayload }>();
+const CACHE_TTL_MS = 5_000;
+
+async function resolvePayload(dbPath: string): Promise<ResolvedPayload> {
+  const root = repoRoot(dbPath);
+  const key = root;
+  const hit = cache.get(key);
+  if (hit && Date.now() - hit.ts < CACHE_TTL_MS) return hit.data;
+
+  const helper = helperPath();
+  if (!existsSync(helper)) {
+    throw new Error(`roster helper not found: ${helper}`);
+  }
+
+  const proc = Bun.spawn(
+    ["python3", helper, root],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exit = await proc.exited;
+  if (exit !== 0) {
+    throw new Error(`roster resolve failed (${exit}): ${stderr.trim() || "unknown error"}`);
+  }
+
+  const data = JSON.parse(stdout) as ResolvedPayload;
+  cache.set(key, { ts: Date.now(), data });
+  return data;
+}
+
+export async function rosters(dbPath: string): Promise<RostersResponse> {
+  return (await resolvePayload(dbPath)).rosters;
+}
+
+export async function roster(dbPath: string, name: string): Promise<RosterInfo> {
+  const list = await rosters(dbPath);
+  const found = list.find((r) => r.name === name);
+  if (!found) throw new Error(`unknown roster '${name}'`);
+  return found;
+}
+
+export async function models(dbPath: string): Promise<ModelsResponse> {
+  return (await resolvePayload(dbPath)).models;
+}

package/apps/smidja-factory/apps/visualizer/server/roster_resolve.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Resolve the target repo's roster.yaml into the JSON the chat picker needs.
+
+Emits a single JSON object on stdout:
+
+    { "rosters": [RosterInfo...], "models": [ModelInfo...] }
+
+Mirrors scripts/resolve-config.py's exact model resolution for each stack
+(overrides > tier map > defaults) so the UI picker reflects what a real
+`smidja run` would use, but leaves the yaml on disk untouched — this is
+read-only, for the picker only.
+
+Usage:
+    python3 server/roster_resolve.py <repoRoot> [roster.yaml-path]
+"""
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+ROLE_COLORS = {
+    "orchestrator": "#c084fc", "planner": "#a78bfa", "builder": "#22d3ee",
+    "scout": "#fbbf24", "reviewer": "#fb7185", "documenter": "#e879f9",
+}
+
+
+def _expand(value: str) -> str:
+    """Expand ${VAR:-default} in a model id using the current environment."""
+    if not isinstance(value, str):
+        return value
+    pattern = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}")
+    return pattern.sub(lambda m: os.environ.get(m.group(1), m.group(2) or ""), value)
+
+
+def _tiers(r: dict) -> dict:
+    return r.get("tiers") or r.get("model_presets") or {}
+
+
+def _surface(provider: str) -> str:
+    if provider in ("lmstudio", "ollama", "local"):
+        return "local"
+    return "cloud"
+
+
+def _size_b(model: str) -> int | None:
+    """Best-effort parameter size from the model id, e.g. '35b-a3b' -> 35."""
+    m = re.search(r"(\d+(?:\.\d+)?)b", model.lower())
+    if not m:
+        return None
+    try:
+        return int(float(m.group(1)))
+    except ValueError:
+        return None
+
+
+def _provider(model: str) -> str:
+    parts = model.split("/")
+    return parts[0] if len(parts) > 1 else "local"
+
+
+def _weak(model: str) -> bool:
+    size = _size_b(model)
+    if size is not None:
+        return size < 9
+    # Explicit small-model hints when size parsing fails.
+    return bool(re.search(r"(?:^|[^0-9])(4b|7b|8b|0\.6b|0\.5b)(?:[^0-9]|$)", model.lower()))
+
+
+def resolve_rosters_and_models(repo_root: Path, roster_path: Path | None = None) -> dict:
+    r = roster_path or repo_root / "smidja" / "smidja_config" / "roster.yaml"
+    data = {}
+    if r and r.exists():
+        import yaml
+        try:
+            data = yaml.safe_load(r.read_text()) or {}
+        except Exception:
+            data = {}
+
+    defaults = data.get("role_defaults") or {}
+    tier_map_by_name = {k: v or {} for k, v in _tiers(data).items()}
+    stacks = data.get("stacks") or {}
+    role_default_names = list((data.get("model_roles") or {}).keys()) or ["defaults"]
+
+    rosters = []
+    models_by_id: dict[str, dict] = {}
+
+    def note_model(model: str) -> None:
+        model = _expand(model)
+        if not model or model in models_by_id:
+            return
+        provider = _provider(model)
+        models_by_id[model] = {
+            "id": model,
+            "name": model.split("/")[-1],
+            "provider": provider,
+            "kind": "local" if _surface(provider) == "local" else "online",
+            "size_b": _size_b(model),
+            "weak": _weak(model),
+        }
+
+    for name, stack in stacks.items():
+        tier = stack.get("tier")
+        tier_map = tier_map_by_name.get(tier or "", {})
+        overrides = stack.get("overrides") or {}
+        agents = stack.get("agents") or []
+
+        resolved = []
+        for aname in agents:
+            ov = overrides.get(aname) or {}
+            role_default = defaults.get(aname) or {}
+            model = ov.get("model") or tier_map.get(aname) or tier_map.get("defaults", "")
+            # Fall back to role_defaults model if one is pinned there.
+            if not model and role_default.get("model"):
+                model = role_default["model"]
+            model = _expand(model)
+            if model:
+                note_model(model)
+            resolved.append({"role": aname, "model": model})
+
+        orchestrator_model = ""
+        orch_entry = next((a for a in resolved if a["role"] == "orchestrator"), None)
+        if orch_entry and orch_entry["model"]:
+            orchestrator_model = orch_entry["model"]
+        else:
+            orchestrator_model = _expand(
+                overrides.get("orchestrator", {}).get("model")
+                or tier_map.get("orchestrator")
+                or role_defaults_model(data, "orchestrator")
+                or ""
+            )
+            if orchestrator_model:
+                note_model(orchestrator_model)
+
+        # Surface: any agent on local provider -> local; mixed -> hybrid.
+        surfaces = {_surface(_provider(a["model"])) for a in resolved if a["model"]}
+        surface = "hybrid" if len(surfaces) > 1 else (next(iter(surfaces), "local"))
+
+        label = f"{name} — {len(agents)} agents"
+        if tier:
+            label += f" · {tier}"
+        elif not agents:
+            label = name
+
+        rosters.append({
+            "name": name,
+            "label": label,
+            "surface": surface,
+            "tier": tier or "",
+            "agent_count": len(agents),
+            "orchestrator_model": orchestrator_model,
+            "weak_orchestrator": bool(orchestrator_model and _weak(orchestrator_model)),
+            "agents": resolved,
+            "summary": (resolved and ", ".join(a["role"] for a in resolved)) or None,
+        })
+
+    return {"rosters": rosters, "models": list(models_by_id.values())}
+
+
+def role_defaults_model(data: dict, role: str) -> str:
+    rd = (data.get("role_defaults") or {}).get(role) or {}
+    return rd.get("model", "")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit("usage: roster_resolve.py <repoRoot> [roster.yaml]")
+    repo = Path(sys.argv[1]).resolve()
+    rp = Path(sys.argv[2]).resolve() if len(sys.argv) > 2 else None
+    print(json.dumps(resolve_rosters_and_models(repo, rp), indent=0))

package/apps/smidja-factory/apps/visualizer/server/settings.ts

@@ -0,0 +1,106 @@
+/**
+ * Local settings — WayOfTeams MCP keys for the orchestrator chat (Kaia).
+ *
+ * Keys are stored in the target repo's `.env` (gitignored per repo convention),
+ * chmod 600. The GET endpoint NEVER returns a secret's value — only whether it
+ * is set plus a masked hint (last 4 chars), so a public tunnel cannot leak it.
+ * POST updates allowlisted keys only.
+ */
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { join } from "node:path";
+
+/** Keys the settings page may read/write. Everything else is rejected. */
+export const SETTING_KEYS = [
+  "WAYOFTEAMS_MCP_TOKEN", // WayOfTeams per-user JWT (MCP bearer)
+  "WOTEAMS_MCP_URL",      // base endpoint (no default — the operator sets their own)
+  "WOTEAMS_AGENT_NAME",   // identity in the work registry
+  "WOTEAMS_AGENT_ID",
+] as const;
+
+export type SettingKey = (typeof SETTING_KEYS)[number];
+
+export interface SettingInfo {
+  key: SettingKey;
+  set: boolean;
+  /** Masked hint for secrets (last 4 chars); plain value for non-secrets (URLs/names). */
+  masked: string;
+}
+
+const SECRET_KEYS: ReadonlySet<string> = new Set(["WAYOFTEAMS_MCP_TOKEN"]);
+
+function envPath(root: string): string {
+  return join(root, ".env");
+}
+
+/** Parse a .env file into an ordered map (Key → value). Line/order preserved on write. */
+export function parseEnv(text: string): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const line of text.split(/\r?\n/)) {
+    const m = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line.trim());
+    if (m) out.set(m[1], m[2]);
+  }
+  return out;
+}
+
+function readEnv(root: string): Map<string, string> {
+  const p = envPath(root);
+  if (!existsSync(p)) return new Map();
+  return parseEnv(readFileSync(p, "utf8"));
+}
+
+function mask(value: string, key: string): string {
+  if (SECRET_KEYS.has(key)) {
+    const last = value.length > 4 ? value.slice(-4) : value;
+    return `set · …${last}`;
+  }
+  return value;
+}
+
+export function listSettings(root: string): SettingInfo[] {
+  const env = readEnv(root);
+  return SETTING_KEYS.map((key) => {
+    const v = env.get(key);
+    return { key, set: !!v, masked: v ? mask(v, key) : "" };
+  });
+}
+
+/**
+ * Persist one key into the repo `.env` — update in place if present, append
+ * otherwise; other keys/comments survive; file ends up mode 600.
+ */
+export function saveSetting(root: string, key: string, value: string): SettingInfo {
+  if (!(SETTING_KEYS as readonly string[]).includes(key)) {
+    throw new Error(`unknown setting key "${key}"`);
+  }
+  const clean = value.trim().replace(/\r?\n/g, "");
+  if (clean.length > 4000) throw new Error("value too long");
+  if (/[\0]/.test(clean)) throw new Error("invalid value");
+
+  const p = envPath(root);
+  let text = "";
+  if (existsSync(p)) text = readFileSync(p, "utf8");
+  const lines = text.split(/\r?\n/);
+  const linesOut: string[] = [];
+  let replaced = false;
+  for (const line of lines) {
+    const m = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line.trim());
+    if (m && m[1] === key) {
+      linesOut.push(`${key}=${clean}`);
+      replaced = true;
+    } else {
+      linesOut.push(line);
+    }
+  }
+  if (!replaced) {
+    if (text && !text.endsWith("\n")) linesOut.push("");
+    linesOut.push(`${key}=${clean}`);
+  }
+  writeFileSync(p, linesOut.join("\n"), { mode: 0o600 });
+  try {
+    chmodSync(p, 0o600);
+  } catch {
+    /* chmod not available on all filesystems — best effort */
+  }
+  const v = clean;
+  return { key: key as SettingKey, set: !!v, masked: v ? mask(v, key) : "" };
+}