@opencode_weave/weave 0.7.4 → 0.7.5

package/dist/config/loader.d.ts

@@ -1,2 +1,21 @@
 import { type WeaveConfig } from "./schema";
+export interface ConfigDiagnostic {
+    level: "warn" | "error";
+    section: string;
+    message: string;
+    /** Individual field-level issues within the section */
+    fields?: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+export interface ConfigLoadResult {
+    config: WeaveConfig;
+    /** Config files that were found and loaded (may be empty) */
+    loadedFiles: string[];
+    /** Validation diagnostics — empty when config is fully valid */
+    diagnostics: ConfigDiagnostic[];
+}
+/** Retrieve the most recent config load result (for /weave-health command). */
+export declare function getLastConfigLoadResult(): ConfigLoadResult | null;
 export declare function loadWeaveConfig(directory: string, _ctx?: unknown, _homeDir?: string): WeaveConfig;

package/dist/features/builtin-commands/types.d.ts

@@ -13,4 +13,4 @@ export interface BuiltinCommand {
     /** Hint shown for the argument (e.g., "[plan-name]") */
     argumentHint?: string;
 }
-export type BuiltinCommandName = "start-work" | "token-report" | "metrics" | "run-workflow";
+export type BuiltinCommandName = "start-work" | "token-report" | "metrics" | "run-workflow" | "weave-health";

package/dist/features/health-report.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigLoadResult } from "../config/loader";
+/**
+ * Generate a human-readable health report from the config load result.
+ * Surfaced via the /weave-health command so the user can diagnose
+ * config issues directly in the TUI.
+ */
+export declare function generateHealthReport(loadResult: ConfigLoadResult | null, agents: Record<string, unknown>): string;

package/dist/index.js

@@ -1007,6 +1007,10 @@ function logDelegation(event) {
 }
 
 // src/config/loader.ts
+var lastLoadResult = null;
+function getLastConfigLoadResult() {
+  return lastLoadResult;
+}
 function readJsoncFile(filePath) {
   try {
     const text = readFileSync(filePath, "utf-8");
@@ -1039,13 +1043,37 @@ function loadWeaveConfig(directory, _ctx, _homeDir) {
     userConfig: userConfigPath ?? "(none)",
     projectConfig: projectConfigPath ?? "(none)"
   });
+  const loadedFiles = [];
+  if (userConfigPath)
+    loadedFiles.push(userConfigPath);
+  if (projectConfigPath)
+    loadedFiles.push(projectConfigPath);
   const userRaw = userConfigPath ? readJsoncFile(userConfigPath) : {};
   const projectRaw = projectConfigPath ? readJsoncFile(projectConfigPath) : {};
   const merged = mergeConfigs(userRaw, projectRaw);
   const result = WeaveConfigSchema.safeParse(merged);
   if (!result.success) {
-    error("WeaveConfig validation errors — using defaults", result.error.issues);
-    return WeaveConfigSchema.parse({});
+    const recovery = recoverValidSections(merged, result.error.issues);
+    if (recovery) {
+      lastLoadResult = { config: recovery.config, loadedFiles, diagnostics: recovery.diagnostics };
+      return recovery.config;
+    }
+    const diagnostics = [{
+      level: "error",
+      section: "(root)",
+      message: "Config validation failed entirely — using defaults",
+      fields: result.error.issues.map((i) => ({
+        path: i.path.join(".") || "(root)",
+        message: i.message
+      }))
+    }];
+    error("WeaveConfig validation errors — using defaults. Fix the issues below and restart.", result.error.issues.map((i) => ({
+      path: i.path.join(".") || "(root)",
+      message: i.message
+    })));
+    const fallback = WeaveConfigSchema.parse({});
+    lastLoadResult = { config: fallback, loadedFiles, diagnostics };
+    return fallback;
   }
   debug("Weave config loaded successfully", {
     hasAgentOverrides: !!result.data.agents && Object.keys(result.data.agents).length > 0,
@@ -1054,8 +1082,52 @@ function loadWeaveConfig(directory, _ctx, _homeDir) {
     logLevel: result.data.log_level ?? "(default)",
     analyticsEnabled: result.data.analytics?.enabled ?? false
   });
+  lastLoadResult = { config: result.data, loadedFiles, diagnostics: [] };
   return result.data;
 }
+function recoverValidSections(merged, issues) {
+  const failingKeys = new Set;
+  for (const issue of issues) {
+    if (issue.path.length > 0) {
+      failingKeys.add(String(issue.path[0]));
+    }
+  }
+  if (failingKeys.size === 0)
+    return null;
+  const diagnostics = [];
+  for (const key of failingKeys) {
+    const sectionIssues = issues.filter((i) => i.path.length > 0 && String(i.path[0]) === key);
+    const fields = sectionIssues.map((i) => ({
+      path: i.path.slice(1).join("."),
+      message: i.message
+    }));
+    const details = fields.map((f) => f.path ? `  → ${f.path}: ${f.message}` : `  → ${f.message}`);
+    diagnostics.push({
+      level: "warn",
+      section: key,
+      message: `Section "${key}" was dropped due to validation errors`,
+      fields
+    });
+    warn(`Config section "${key}" has validation errors and was dropped:
+${details.join(`
+`)}
+  Remaining config sections are preserved. Fix the errors above and restart.`);
+  }
+  const stripped = { ...merged };
+  for (const key of failingKeys) {
+    delete stripped[key];
+  }
+  const retry = WeaveConfigSchema.safeParse(stripped);
+  if (retry.success) {
+    debug("Config recovery succeeded", {
+      droppedSections: [...failingKeys],
+      hasAgentOverrides: !!retry.data.agents && Object.keys(retry.data.agents).length > 0,
+      customAgents: retry.data.custom_agents ? Object.keys(retry.data.custom_agents) : []
+    });
+    return { config: retry.data, diagnostics };
+  }
+  return null;
+}
 
 // src/shared/agent-display-names.ts
 var AGENT_DISPLAY_NAMES = {
@@ -1218,6 +1290,16 @@ ${RUN_WORKFLOW_TEMPLATE}
 <session-context>Session ID: $SESSION_ID  Timestamp: $TIMESTAMP</session-context>
 <user-request>$ARGUMENTS</user-request>`,
     argumentHint: '<workflow-name> ["goal"]'
+  },
+  "weave-health": {
+    name: "weave-health",
+    description: "Show Weave config health and any validation issues",
+    agent: "loom",
+    template: `<command-instruction>
+Display the Weave health report below to the user. Present warnings and errors prominently.
+If there are no issues, confirm that Weave config is healthy.
+</command-instruction>
+<weave-health>$ARGUMENTS</weave-health>`
   }
 };
 // src/managers/config-handler.ts
@@ -6028,6 +6110,76 @@ function generateMetricsReport(directory, state) {
   }
 }
 
+// src/features/health-report.ts
+function generateHealthReport(loadResult, agents) {
+  if (!loadResult) {
+    return "⚠ No config load result available — Weave may not have initialized properly.";
+  }
+  const lines = [];
+  const { config, loadedFiles, diagnostics } = loadResult;
+  const hasIssues = diagnostics.length > 0;
+  lines.push(hasIssues ? "## ⚠ Weave Config Health: Issues Found" : "## ✅ Weave Config Health: OK");
+  lines.push("");
+  lines.push("### Config Files");
+  if (loadedFiles.length === 0) {
+    lines.push("No config files found (using defaults)");
+  } else {
+    for (const f of loadedFiles) {
+      lines.push(`- \`${f}\``);
+    }
+  }
+  lines.push("");
+  if (diagnostics.length > 0) {
+    lines.push("### Validation Issues");
+    lines.push("");
+    for (const d of diagnostics) {
+      const icon = d.level === "error" ? "\uD83D\uDD34" : "\uD83D\uDFE1";
+      lines.push(`${icon} **${d.section}**: ${d.message}`);
+      if (d.fields?.length) {
+        for (const f of d.fields) {
+          const fieldLabel = f.path || "(root)";
+          lines.push(`  - \`${fieldLabel}\`: ${f.message}`);
+        }
+      }
+      lines.push("");
+    }
+    lines.push("Fix the issues above in your config file and restart opencode.");
+    lines.push("");
+  }
+  lines.push("### Loaded Agents");
+  const builtinKeys = ["loom", "tapestry", "shuttle", "pattern", "thread", "spindle", "warp", "weft"];
+  const builtinDisplayNames = new Set(builtinKeys.map((k) => getAgentDisplayName(k)));
+  const agentNames = Object.keys(agents);
+  const builtinAgents = agentNames.filter((n) => builtinDisplayNames.has(n));
+  const customAgents = agentNames.filter((n) => !builtinDisplayNames.has(n));
+  lines.push(`- Builtin: ${builtinAgents.length}/8 (${builtinAgents.join(", ")})`);
+  if (customAgents.length > 0) {
+    lines.push(`- Custom: ${customAgents.length} (${customAgents.join(", ")})`);
+  } else {
+    lines.push("- Custom: 0");
+  }
+  lines.push("");
+  if (config.custom_agents && Object.keys(config.custom_agents).length > 0) {
+    lines.push("### Custom Agent Config");
+    for (const [name, agentConfig] of Object.entries(config.custom_agents)) {
+      const mode = agentConfig.mode ?? "subagent";
+      const model = agentConfig.model ?? "(default)";
+      lines.push(`- **${agentConfig.display_name ?? name}** — mode: ${mode}, model: ${model}`);
+    }
+    lines.push("");
+  }
+  const disabled = config.disabled_agents ?? [];
+  if (disabled.length > 0) {
+    lines.push(`### Disabled Agents: ${disabled.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("### Logs");
+  lines.push("Detailed logs: `~/.local/share/opencode/log/` (grep for `service=weave`)");
+  lines.push("Real-time: `opencode --print-logs --log-level WARN`");
+  return lines.join(`
+`);
+}
+
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
   const { pluginConfig, hooks, tools, configHandler, agents, client: client2, directory = "", tracker } = args;
@@ -6462,6 +6614,11 @@ ${cmdResult.contextInjection}`;
         const metricsMarkdown = formatMetricsMarkdown(reports, summaries, args2);
         parts.push({ type: "text", text: metricsMarkdown });
       }
+      if (command === "weave-health") {
+        const loadResult = getLastConfigLoadResult();
+        const reportText = generateHealthReport(loadResult, agents);
+        parts.push({ type: "text", text: reportText });
+      }
     },
     "tool.definition": async (input, output) => {
       if (hooks.todoDescriptionOverride) {
@@ -6890,8 +7047,8 @@ function createAnalytics(directory, fingerprint) {
 
 // src/index.ts
 var WeavePlugin = async (ctx) => {
-  const pluginConfig = loadWeaveConfig(ctx.directory, ctx);
   setClient(ctx.client);
+  const pluginConfig = loadWeaveConfig(ctx.directory, ctx);
   if (pluginConfig.log_level) {
     setLogLevel(pluginConfig.log_level);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode_weave/weave",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Weave — lean OpenCode plugin with multi-agent orchestration",
   "author": "Weave",
   "license": "MIT",