@weave-tools/weave-it 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/commands/add.ts
 import { Command } from "commander";
@@ -18,60 +18,60 @@ import { realpath } from "fs/promises";
 import { constants } from "fs";
 import { access, mkdir, readFile, readdir, rename, stat, writeFile } from "fs/promises";
 import { dirname } from "path";
-async function pathExists(path14) {
+async function pathExists(path16) {
   try {
-    await access(path14, constants.F_OK);
+    await access(path16, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function writeNewFile(path14, contents) {
-  await writeFile(path14, contents, { flag: "wx" });
+async function writeNewFile(path16, contents) {
+  await writeFile(path16, contents, { flag: "wx" });
 }
-async function writeFileIfMissing(path14, contents) {
-  if (await pathExists(path14)) {
+async function writeFileIfMissing(path16, contents) {
+  if (await pathExists(path16)) {
     return false;
   }
-  await writeNewFile(path14, contents);
+  await writeNewFile(path16, contents);
   return true;
 }
-async function writeFileAtomic(path14, contents) {
-  const tempPath = `${path14}.${process.pid}.tmp`;
+async function writeFileAtomic(path16, contents) {
+  const tempPath = `${path16}.${process.pid}.tmp`;
   await writeFile(tempPath, contents);
-  await rename(tempPath, path14);
+  await rename(tempPath, path16);
 }
-async function ensureDir(path14) {
-  await mkdir(path14, { recursive: true });
+async function ensureDir(path16) {
+  await mkdir(path16, { recursive: true });
 }
-async function createDirExclusive(path14) {
-  await mkdir(path14, { recursive: false });
+async function createDirExclusive(path16) {
+  await mkdir(path16, { recursive: false });
 }
-async function ensureDirectory(path14) {
-  const value = await stat(path14);
+async function ensureDirectory(path16) {
+  const value = await stat(path16);
   if (!value.isDirectory()) {
-    throw new Error(`Expected a directory: ${path14}`);
+    throw new Error(`Expected a directory: ${path16}`);
   }
 }
-async function isDirectoryEmpty(path14) {
-  const entries = await readdir(path14);
+async function isDirectoryEmpty(path16) {
+  const entries = await readdir(path16);
   return entries.length === 0;
 }
 async function movePath(source, target) {
   await rename(source, target);
 }
-async function readJsonCache(path14) {
+async function readJsonCache(path16) {
   try {
-    const contents = await readFile(path14, "utf8");
+    const contents = await readFile(path16, "utf8");
     return JSON.parse(contents);
   } catch {
     return null;
   }
 }
-async function writeJsonCache(path14, data) {
+async function writeJsonCache(path16, data) {
   try {
-    await mkdir(dirname(path14), { recursive: true });
-    await writeFileAtomic(path14, JSON.stringify(data, null, 2));
+    await mkdir(dirname(path16), { recursive: true });
+    await writeFileAtomic(path16, JSON.stringify(data, null, 2));
     return true;
   } catch {
     return false;
@@ -302,6 +302,7 @@ async function ensureWeaveScaffold(input) {
   const knowledgeReadme = knowledgeReadmeTemplate();
   const domainsReadme = domainsReadmeTemplate();
   const sharedReadme = sharedReadmeTemplate();
+  const architectureConsiderations = architectureConsiderationsTemplate();
   const knowledgeDir = path3.join(wikiDir, "knowledge");
   const changesDir = path3.join(wikiDir, "changes");
   const changesExisted = await pathExists(changesDir);
@@ -313,6 +314,9 @@ async function ensureWeaveScaffold(input) {
   if (await writeFileIfMissing(path3.join(metadataDir, "sync.yml"), syncTemplate(knowledgeIndex))) {
     created.push(".weave/sync.yml");
   }
+  if (await writeFileIfMissing(path3.join(metadataDir, "architecture-considerations.md"), architectureConsiderations)) {
+    created.push(".weave/architecture-considerations.md");
+  }
   if (await writeFileIfMissing(path3.join(knowledgeDir, "index.md"), knowledgeIndex)) {
     created.push("wiki/knowledge/index.md");
   }
@@ -358,6 +362,49 @@ Examples:
 - Notifications
 `;
 }
+function architectureConsiderationsTemplate() {
+  return `# Architecture Considerations
+
+This file is user-owned. Weave creates it once and never overwrites it.
+
+Use this file to capture team-specific architecture guidance that agents should keep in mind when discussing technical design.
+
+## Design Principles
+
+- _Add preferred design principles here._
+
+## Patterns To Prefer
+
+- _Example: Prefer service objects for cross-domain workflows._
+
+## Patterns To Avoid
+
+- _Example: Avoid callback-driven cross-domain side effects._
+
+## Data Access And Scaling
+
+- _Example: Watch for N+1 queries in list/detail views._
+- _Example: Prefer batched reads for high-cardinality associations._
+
+## Caching And Consistency
+
+- _Add caching rules, invalidation expectations, or consistency constraints._
+
+## Async Boundaries And Events
+
+- _Add guidance for jobs, queues, events, callbacks, or synchronous flows._
+
+## Observability And Operations
+
+- _Add logging, metrics, alerting, rollout, and failure-mode expectations._
+
+## Notes For Agents
+
+- Apply relevant guidance silently.
+- Surface only constraints, conflicts, or risks that materially affect the design.
+- Do not treat examples as mandatory unless this file says they are.
+`;
+}
 function knowledgeReadmeTemplate() {
   return `# Knowledge Structure
 
@@ -1274,8 +1321,8 @@ function formatFullFileDiff(installedPath, defaultName, installed, currentDefaul
 function splitLines(value) {
   return value.endsWith("\n") ? value.slice(0, -1).split("\n") : value.split("\n");
 }
-function result(agent, artifact, path14, status, message) {
-  return { agent, kind: artifact.kind, skill: artifact.name, path: path14, status, message };
+function result(agent, artifact, path16, status, message) {
+  return { agent, kind: artifact.kind, skill: artifact.name, path: path16, status, message };
 }
 function summarize(results) {
   return {
@@ -2991,9 +3038,9 @@ async function safeListDefaultSkills(templatesDir) {
     return [];
   }
 }
-async function safeHashFile(path14) {
+async function safeHashFile(path16) {
   try {
-    const content = await readFile8(path14, "utf8");
+    const content = await readFile8(path16, "utf8");
     return `sha256:${createHash3("sha256").update(content).digest("hex")}`;
   } catch {
     return null;
@@ -3337,13 +3384,409 @@ function errorResult2(error) {
   };
 }
 
-// src/commands/init.ts
+// src/commands/doctor.ts
 import { Command as Command5 } from "commander";
 
+// src/lib/doctor.ts
+import path10 from "path";
+
+// src/lib/status.ts
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile10 } from "fs/promises";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, join as join5 } from "path";
+var agentOrder = ["claude", "codex", "cursor", "opencode"];
+async function buildStatus(options) {
+  const packageVersion = options.packageVersion ?? await readPackageVersion2();
+  const inRepo = await pathExists(join5(options.cwd, ".weave", "agents.yml"));
+  const skills = inRepo ? await collectSkillRows(options) : [];
+  const npmLatest = options.npmLatest === void 0 ? (await getNpmVersionInfo({ packageVersion, env: options.env })).cachedLatest : options.npmLatest;
+  const notices = await gatherNotices({
+    cwd: options.cwd,
+    packageVersion,
+    npmLatest: npmLatest ?? null,
+    templatesDir: options.templatesDir,
+    env: options.env
+  });
+  return {
+    status: "ok",
+    packageVersion,
+    cwd: options.cwd,
+    inRepo,
+    skills,
+    notices,
+    message: renderStatusMessage({
+      packageVersion,
+      cwd: options.cwd,
+      inRepo,
+      skills,
+      notices,
+      npmLatest: npmLatest ?? null
+    })
+  };
+}
+async function collectSkillRows(options) {
+  const manifest = await loadAgentsManifest(options.cwd);
+  const templates = await listDefaultSkills({ templatesDir: options.templatesDir }).catch(() => []);
+  const templatesByName = new Map(templates.map((skill) => [skill.name, skill]));
+  const rows = [];
+  for (const agent of agentOrder) {
+    const buckets = manifest.installed[agent];
+    if (!buckets) continue;
+    const skills = buckets.skills ?? {};
+    for (const [name, entry] of Object.entries(skills)) {
+      const template = templatesByName.get(name);
+      const current = template?.lastChangedIn ?? "unknown";
+      const absolutePath = join5(options.cwd, entry.path);
+      const fileExists = await pathExists(absolutePath);
+      let state = "current";
+      if (!fileExists) {
+        state = "missing";
+      } else {
+        const diskContent = await readFile10(absolutePath, "utf8").catch(() => "");
+        const diskHash = `sha256:${createHash4("sha256").update(diskContent).digest("hex")}`;
+        if (diskHash !== entry.installed_hash) {
+          state = "modified";
+        } else if (template && entry.installed_from !== template.lastChangedIn) {
+          state = "outdated";
+        }
+      }
+      rows.push({
+        agent,
+        name,
+        installed_from: entry.installed_from,
+        current,
+        state
+      });
+    }
+  }
+  return rows;
+}
+function renderStatusMessage(opts) {
+  const lines = [];
+  lines.push(`weave-it ${opts.packageVersion}`);
+  lines.push(`cwd: ${opts.cwd}`);
+  if (opts.npmLatest) {
+    lines.push(`npm latest (cached): ${opts.npmLatest}`);
+  } else {
+    lines.push(`npm latest (cached): unknown`);
+  }
+  if (!opts.inRepo) {
+    lines.push("");
+    lines.push("Not inside a Weave-managed repo (no .weave/agents.yml).");
+  } else if (opts.skills.length === 0) {
+    lines.push("");
+    lines.push("No skills installed.");
+  } else {
+    lines.push("");
+    lines.push("Installed skills:");
+    const header = ["agent", "skill", "state", "installed_from", "current"];
+    const rows = opts.skills.map((row) => [
+      row.agent,
+      row.name,
+      row.state,
+      row.installed_from ?? "unknown",
+      row.current
+    ]);
+    const widths = header.map(
+      (cell, index) => Math.max(cell.length, ...rows.map((row) => row[index].length))
+    );
+    const renderRow = (cells) => cells.map((cell, index) => cell.padEnd(widths[index])).join("  ").trimEnd();
+    lines.push(renderRow(header));
+    lines.push(widths.map((width) => "-".repeat(width)).join("  ").trimEnd());
+    for (const row of rows) {
+      lines.push(renderRow(row));
+    }
+  }
+  lines.push("");
+  if (opts.notices.length === 0) {
+    lines.push("Notices: none.");
+  } else {
+    lines.push(`Notices (${opts.notices.length}):`);
+    for (const notice of opts.notices) {
+      lines.push(`- [${notice.kind}] ${notice.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function readPackageVersion2() {
+  const moduleDir = dirname4(fileURLToPath3(import.meta.url));
+  let current = moduleDir;
+  while (true) {
+    const candidate = join5(current, "package.json");
+    if (await pathExists(candidate)) {
+      try {
+        const parsed = JSON.parse(await readFile10(candidate, "utf8"));
+        if (typeof parsed?.version === "string") {
+          return parsed.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname4(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "0.0.0";
+}
+
+// src/lib/doctor.ts
+var safeScaffoldFiles = [
+  ".weave/sync.yml",
+  ".weave/architecture-considerations.md",
+  "wiki/knowledge/index.md",
+  "wiki/knowledge/README.md",
+  "wiki/knowledge/domains/README.md",
+  "wiki/knowledge/shared/README.md"
+];
+var safeScaffoldDirs = [
+  "wiki/changes",
+  "wiki/knowledge/domains",
+  "wiki/knowledge/shared",
+  ".weave"
+];
+async function buildDoctor(options) {
+  const cwd = options.cwd;
+  const fix = options.fix ?? false;
+  const workspace = await findWorkspaceMode(cwd);
+  const checks = [];
+  let changed = [];
+  let activeChange = null;
+  let skills = [];
+  if (!workspace) {
+    checks.push({
+      id: "weave_context",
+      status: "error",
+      message: "No readable Weave metadata found. Run `weave init` first.",
+      fixable: false
+    });
+    return renderResult({ cwd, workspace: null, activeChange, checks, changed });
+  }
+  checks.push({
+    id: "weave_context",
+    status: "ok",
+    message: `Weave metadata found: ${path10.relative(workspace.workspacePath, workspace.workspaceYmlPath)}`,
+    fixable: false
+  });
+  const missingScaffold = await missingSafeScaffold(workspace.workspacePath);
+  if (fix && missingScaffold.length > 0) {
+    const scaffold = await ensureWeaveScaffold({ folder: { path: workspace.workspacePath } });
+    changed = scaffold.created;
+  }
+  const remainingMissingScaffold = await missingSafeScaffold(workspace.workspacePath);
+  if (remainingMissingScaffold.length > 0) {
+    checks.push({
+      id: "safe_scaffold",
+      status: "warning",
+      message: "Missing safe scaffold files.",
+      fixable: true,
+      files: remainingMissingScaffold,
+      details: ["Fix: weave doctor --fix"]
+    });
+  } else {
+    checks.push({
+      id: "safe_scaffold",
+      status: "ok",
+      message: "Safe scaffold files found.",
+      fixable: false
+    });
+  }
+  const missingDirs = await missingSafeDirs(workspace.workspacePath);
+  if (missingDirs.length > 0) {
+    checks.push({
+      id: "safe_scaffold_dirs",
+      status: "warning",
+      message: "Missing safe scaffold directories.",
+      fixable: true,
+      files: missingDirs,
+      details: ["Fix: weave doctor --fix"]
+    });
+  } else {
+    checks.push({
+      id: "safe_scaffold_dirs",
+      status: "ok",
+      message: "Safe scaffold directories found.",
+      fixable: false
+    });
+  }
+  if (await pathExists(path10.join(workspace.workspacePath, ".weave", "agents.yml"))) {
+    skills = await collectSkillRows({
+      cwd: workspace.workspacePath,
+      templatesDir: options.templatesDir
+    }).catch(() => []);
+    const drift = skills.filter((row) => row.state !== "current");
+    if (drift.length > 0) {
+      checks.push({
+        id: "skill_drift",
+        status: "warning",
+        message: "Installed skills differ from bundled templates.",
+        fixable: false,
+        details: drift.map((row) => `${row.agent}/${row.name}: ${row.state}`)
+      });
+    } else {
+      checks.push({
+        id: "skill_drift",
+        status: "ok",
+        message: skills.length > 0 ? "Installed skills are current." : "No installed skills found.",
+        fixable: false
+      });
+    }
+  } else {
+    checks.push({
+      id: "skill_drift",
+      status: "ok",
+      message: "No installed skill manifest found.",
+      fixable: false
+    });
+  }
+  activeChange = await readActiveChange(workspace.workspacePath, options.sessionPath ?? defaultSessionPath());
+  if (activeChange) {
+    checks.push({
+      id: "active_change",
+      status: activeChange.branchMatch === false ? "warning" : "ok",
+      message: activeChange.branchMatch === false ? `Active change branch mismatch: expected ${activeChange.branch}, current ${activeChange.currentBranch ?? "unknown"}.` : `Active change found: ${activeChange.id}.`,
+      fixable: false
+    });
+  } else {
+    checks.push({
+      id: "active_change",
+      status: "warning",
+      message: "No active change found for this context.",
+      fixable: false
+    });
+  }
+  return renderResult({ cwd, workspace, activeChange, checks, changed });
+}
+async function missingSafeScaffold(root) {
+  const missing = [];
+  for (const file of safeScaffoldFiles) {
+    if (!await pathExists(path10.join(root, file))) {
+      missing.push(file);
+    }
+  }
+  return missing;
+}
+async function missingSafeDirs(root) {
+  const missing = [];
+  for (const dir of safeScaffoldDirs) {
+    if (!await pathExists(path10.join(root, dir))) {
+      missing.push(dir);
+    }
+  }
+  return missing;
+}
+async function readActiveChange(root, sessionPath) {
+  try {
+    const session = await loadCurrentSession(sessionPath);
+    if (!session) return null;
+    const folderId = findFolderByPath(session, root);
+    const current = folderId ? session.folders[folderId]?.current_change : void 0;
+    if (!current) return null;
+    const branch = await currentBranch(root) ?? null;
+    return {
+      id: current.id,
+      branch: current.branch,
+      branchMatch: branch ? branch === current.branch : null,
+      currentBranch: branch
+    };
+  } catch {
+    return null;
+  }
+}
+function renderResult(input) {
+  const status = overallStatus(input.checks);
+  return {
+    status,
+    cwd: input.cwd,
+    mode: input.workspace?.mode ?? null,
+    root: input.workspace?.workspacePath ?? null,
+    activeChange: input.activeChange,
+    checks: input.checks,
+    changed: input.changed,
+    message: renderDoctorMessage({
+      status,
+      cwd: input.cwd,
+      workspace: input.workspace,
+      activeChange: input.activeChange,
+      checks: input.checks,
+      changed: input.changed
+    })
+  };
+}
+function overallStatus(checks) {
+  if (checks.some((check) => check.status === "error")) return "error";
+  if (checks.some((check) => check.status === "warning")) return "warning";
+  return "ok";
+}
+function renderDoctorMessage(input) {
+  const lines = [];
+  lines.push("Weave Doctor");
+  lines.push("");
+  lines.push("Context");
+  lines.push(`- Cwd: ${input.cwd}`);
+  lines.push(`- Root: ${input.workspace?.workspacePath ?? "unknown"}`);
+  lines.push(`- Mode: ${input.workspace?.mode ?? "unknown"}`);
+  lines.push(`- Active change: ${input.activeChange?.id ?? "none"}`);
+  lines.push(`- Branch: ${input.activeChange?.currentBranch ?? "unknown"}`);
+  lines.push("");
+  lines.push("Checks");
+  for (const check of input.checks) {
+    lines.push(`${statusPrefix(check.status)} ${check.message}`);
+    for (const file of check.files ?? []) {
+      lines.push(`  - ${file}`);
+    }
+    for (const detail of check.details ?? []) {
+      lines.push(`  ${detail}`);
+    }
+  }
+  lines.push("");
+  lines.push("Summary");
+  lines.push(`- Status: ${input.status}`);
+  lines.push(`- Passed: ${input.checks.filter((check) => check.status === "ok").length}`);
+  lines.push(`- Warnings: ${input.checks.filter((check) => check.status === "warning").length}`);
+  lines.push(`- Errors: ${input.checks.filter((check) => check.status === "error").length}`);
+  if (input.changed.length === 0) {
+    lines.push("- No files were changed.");
+  } else {
+    lines.push("- Files changed:");
+    for (const file of input.changed) {
+      lines.push(`  - ${file}`);
+    }
+  }
+  return lines.join("\n");
+}
+function statusPrefix(status) {
+  if (status === "ok") return "[ok]";
+  if (status === "warning") return "[warning]";
+  return "[error]";
+}
+
+// src/commands/doctor.ts
+function doctorCommand() {
+  return new Command5("doctor").description("Inspect Weave project health and optionally repair missing safe scaffold files.").option("--fix", "create missing safe scaffold files without overwriting existing files").option("--json", "print machine-readable JSON").action(async (options) => {
+    const json = options.json ?? false;
+    await withNotices({ commandName: "doctor", json }, async () => {
+      const result3 = await buildDoctor({
+        cwd: process.cwd(),
+        fix: options.fix ?? false
+      });
+      const { message: _message, ...rest } = result3;
+      return {
+        json: rest,
+        text: result3.message,
+        exitCode: result3.status === "error" ? 1 : 0
+      };
+    });
+  });
+}
+
+// src/commands/init.ts
+import { Command as Command6 } from "commander";
+
 // src/lib/init-workspace.ts
 import * as prompts from "@clack/prompts";
-import { readFile as readFile10, realpath as realpath5 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile11, realpath as realpath5 } from "fs/promises";
+import path11 from "path";
 import YAML8 from "yaml";
 async function initWorkspace(options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -3413,7 +3856,7 @@ async function initWorkspaceMode(options) {
   return initWorkspaceWithoutGitRepo(options);
 }
 async function initWorkspaceFromGitRepo(options, gitRoot) {
-  const repoDirectoryName = path10.basename(gitRoot);
+  const repoDirectoryName = path11.basename(gitRoot);
   const defaultWorkspaceName = `${repoDirectoryName}-workspace`;
   if ((options.yes || options.interactive === false) && !options.workspacePath && await isWeaveSourceRepo(gitRoot)) {
     throw new Error(
@@ -3424,8 +3867,8 @@ async function initWorkspaceFromGitRepo(options, gitRoot) {
   if (workspaceName === "cancelled") {
     return cancelledWorkspace(options.cwd, options.sessionPath);
   }
-  const workspacePath = options.workspacePath ? path10.resolve(options.cwd, options.workspacePath) : path10.join(path10.dirname(gitRoot), slugify(workspaceName, "workspace"));
-  const repoTargetPath = path10.join(workspacePath, repoDirectoryName);
+  const workspacePath = options.workspacePath ? path11.resolve(options.cwd, options.workspacePath) : path11.join(path11.dirname(gitRoot), slugify(workspaceName, "workspace"));
+  const repoTargetPath = path11.join(workspacePath, repoDirectoryName);
   await assertPathMissing(workspacePath, "Workspace path already exists");
   await assertPathMissing(repoTargetPath, "Repo target path already exists");
   const remote = await getGitRemote(gitRoot);
@@ -3461,8 +3904,8 @@ async function initWorkspaceFromGitRepo(options, gitRoot) {
       commitCreated
     }),
     folderPath: folder.path,
-    wikiDir: path10.join(resolvedWorkspacePath, "wiki"),
-    metadataDir: path10.join(resolvedWorkspacePath, ".weave"),
+    wikiDir: path11.join(resolvedWorkspacePath, "wiki"),
+    metadataDir: path11.join(resolvedWorkspacePath, ".weave"),
     sessionPath: options.sessionPath,
     commitCreated,
     warning: commitCreated ? void 0 : "Initial workspace commit was not created. Run git status in the workspace to recover."
@@ -3473,7 +3916,7 @@ async function initWorkspaceWithoutGitRepo(options) {
   if (workspacePath === "cancelled") {
     return cancelledWorkspace(options.cwd, options.sessionPath);
   }
-  const workspaceName = await resolveWorkspaceName(options, path10.basename(workspacePath));
+  const workspaceName = await resolveWorkspaceName(options, path11.basename(workspacePath));
   if (workspaceName === "cancelled") {
     return cancelledWorkspace(options.cwd, options.sessionPath);
   }
@@ -3509,8 +3952,8 @@ async function initWorkspaceWithoutGitRepo(options) {
       commitCreated
     }),
     folderPath: folder.path,
-    wikiDir: path10.join(folder.path, "wiki"),
-    metadataDir: path10.join(folder.path, ".weave"),
+    wikiDir: path11.join(folder.path, "wiki"),
+    metadataDir: path11.join(folder.path, ".weave"),
     sessionPath: options.sessionPath,
     commitCreated,
     warning: commitCreated ? void 0 : "Initial workspace commit was not created. Run git status in the workspace to recover."
@@ -3582,14 +4025,14 @@ async function resolveWorkspaceName(options, defaultName) {
 }
 async function resolveWorkspacePath(options) {
   if (options.workspacePath) {
-    return path10.resolve(options.cwd, options.workspacePath);
+    return path11.resolve(options.cwd, options.workspacePath);
   }
   if (options.yes || options.interactive === false) {
     throw new Error("Workspace path is required for workspace mode outside a git repo.");
   }
   const answer = await prompts.text({
     message: "Workspace path",
-    placeholder: path10.join(path10.dirname(options.cwd), "my-workspace")
+    placeholder: path11.join(path11.dirname(options.cwd), "my-workspace")
   });
   if (prompts.isCancel(answer)) {
     prompts.cancel("Cancelled.");
@@ -3599,11 +4042,11 @@ async function resolveWorkspacePath(options) {
   if (!value) {
     throw new Error("Workspace path is required for workspace mode outside a git repo.");
   }
-  return path10.resolve(options.cwd, value);
+  return path11.resolve(options.cwd, value);
 }
 async function writeRepoWorkspaceMetadata(folder) {
   return writeFileIfMissing(
-    path10.join(folder.path, ".weave", "workspace.yml"),
+    path11.join(folder.path, ".weave", "workspace.yml"),
     workspaceMetadataTemplate({
       mode: "repo",
       name: folder.name,
@@ -3617,7 +4060,7 @@ async function scaffoldWorkspace(input) {
   const scaffold = await ensureWeaveScaffold({ folder });
   const created = [...scaffold.created];
   if (await writeFileIfMissing(
-    path10.join(input.workspacePath, ".weave", "workspace.yml"),
+    path11.join(input.workspacePath, ".weave", "workspace.yml"),
     workspaceMetadataTemplate({
       mode: "workspace",
       name: input.workspaceName,
@@ -3627,7 +4070,7 @@ async function scaffoldWorkspace(input) {
     created.push(".weave/workspace.yml");
   }
   if (await writeFileIfMissing(
-    path10.join(input.workspacePath, ".gitignore"),
+    path11.join(input.workspacePath, ".gitignore"),
     workspaceGitignoreBaseTemplate()
   )) {
     created.push(".gitignore");
@@ -3668,7 +4111,7 @@ async function assertPathMissing(targetPath, message) {
 }
 async function isWeaveSourceRepo(gitRoot) {
   try {
-    const manifest = JSON.parse(await readFile10(path10.join(gitRoot, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile11(path11.join(gitRoot, "package.json"), "utf8"));
     return manifest.name === "weave-it";
   } catch {
     return false;
@@ -3731,7 +4174,7 @@ Next:
 
 // src/commands/init.ts
 function initCommand() {
-  return new Command5("init").description("Initialize Weave in repo mode or workspace mode and start a new session.").option("--id <id>", "folder id").option("--kind <kind>", "folder kind", "app").option("--mode <mode>", "init mode: repo or workspace; defaults to repo with --yes").option("--workspace-name <name>", "workspace name for workspace mode").option("--workspace-path <path>", "workspace path for workspace mode outside a git repo").option("--yes", "accept defaults and skip prompts").action(
+  return new Command6("init").description("Initialize Weave in repo mode or workspace mode and start a new session.").option("--id <id>", "folder id").option("--kind <kind>", "folder kind", "app").option("--mode <mode>", "init mode: repo or workspace; defaults to repo with --yes").option("--workspace-name <name>", "workspace name for workspace mode").option("--workspace-path <path>", "workspace path for workspace mode outside a git repo").option("--yes", "accept defaults and skip prompts").action(
     async (options) => {
       const result3 = await initWorkspace({
         cwd: process.cwd(),
@@ -3753,9 +4196,9 @@ function initCommand() {
 }
 
 // src/commands/skills.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 function skillsCommand() {
-  const command = new Command6("skills").description("List Weave skills.");
+  const command = new Command7("skills").description("List Weave skills.");
   command.command("list").description("List default skills shipped with Weave.").option("--json", "print machine-readable JSON").action(async (options) => {
     await runAction4(async () => {
       const skills = await listDefaultSkills();
@@ -3773,7 +4216,7 @@ function skillsCommand() {
   return command;
 }
 function skillCommand() {
-  const command = new Command6("skill").description("Show Weave skill content.");
+  const command = new Command7("skill").description("Show Weave skill content.");
   command.command("show").description("Print a default skill shipped with Weave.").argument("<name>", "skill name").action(async (name) => {
     await runAction4(async () => {
       const skill = await readDefaultSkill(name);
@@ -3796,151 +4239,9 @@ async function runAction4(action) {
 }
 
 // src/commands/status.ts
-import { Command as Command7 } from "commander";
-
-// src/lib/status.ts
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile11 } from "fs/promises";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname4, join as join5 } from "path";
-var agentOrder = ["claude", "codex", "cursor", "opencode"];
-async function buildStatus(options) {
-  const packageVersion = options.packageVersion ?? await readPackageVersion2();
-  const inRepo = await pathExists(join5(options.cwd, ".weave", "agents.yml"));
-  const skills = inRepo ? await collectSkillRows(options) : [];
-  const npmLatest = options.npmLatest === void 0 ? (await getNpmVersionInfo({ packageVersion, env: options.env })).cachedLatest : options.npmLatest;
-  const notices = await gatherNotices({
-    cwd: options.cwd,
-    packageVersion,
-    npmLatest: npmLatest ?? null,
-    templatesDir: options.templatesDir,
-    env: options.env
-  });
-  return {
-    status: "ok",
-    packageVersion,
-    cwd: options.cwd,
-    inRepo,
-    skills,
-    notices,
-    message: renderStatusMessage({
-      packageVersion,
-      cwd: options.cwd,
-      inRepo,
-      skills,
-      notices,
-      npmLatest: npmLatest ?? null
-    })
-  };
-}
-async function collectSkillRows(options) {
-  const manifest = await loadAgentsManifest(options.cwd);
-  const templates = await listDefaultSkills({ templatesDir: options.templatesDir }).catch(() => []);
-  const templatesByName = new Map(templates.map((skill) => [skill.name, skill]));
-  const rows = [];
-  for (const agent of agentOrder) {
-    const buckets = manifest.installed[agent];
-    if (!buckets) continue;
-    const skills = buckets.skills ?? {};
-    for (const [name, entry] of Object.entries(skills)) {
-      const template = templatesByName.get(name);
-      const current = template?.lastChangedIn ?? "unknown";
-      const absolutePath = join5(options.cwd, entry.path);
-      const fileExists = await pathExists(absolutePath);
-      let state = "current";
-      if (!fileExists) {
-        state = "missing";
-      } else {
-        const diskContent = await readFile11(absolutePath, "utf8").catch(() => "");
-        const diskHash = `sha256:${createHash4("sha256").update(diskContent).digest("hex")}`;
-        if (diskHash !== entry.installed_hash) {
-          state = "modified";
-        } else if (template && entry.installed_from !== template.lastChangedIn) {
-          state = "outdated";
-        }
-      }
-      rows.push({
-        agent,
-        name,
-        installed_from: entry.installed_from,
-        current,
-        state
-      });
-    }
-  }
-  return rows;
-}
-function renderStatusMessage(opts) {
-  const lines = [];
-  lines.push(`weave-it ${opts.packageVersion}`);
-  lines.push(`cwd: ${opts.cwd}`);
-  if (opts.npmLatest) {
-    lines.push(`npm latest (cached): ${opts.npmLatest}`);
-  } else {
-    lines.push(`npm latest (cached): unknown`);
-  }
-  if (!opts.inRepo) {
-    lines.push("");
-    lines.push("Not inside a Weave-managed repo (no .weave/agents.yml).");
-  } else if (opts.skills.length === 0) {
-    lines.push("");
-    lines.push("No skills installed.");
-  } else {
-    lines.push("");
-    lines.push("Installed skills:");
-    const header = ["agent", "skill", "state", "installed_from", "current"];
-    const rows = opts.skills.map((row) => [
-      row.agent,
-      row.name,
-      row.state,
-      row.installed_from ?? "unknown",
-      row.current
-    ]);
-    const widths = header.map(
-      (cell, index) => Math.max(cell.length, ...rows.map((row) => row[index].length))
-    );
-    const renderRow = (cells) => cells.map((cell, index) => cell.padEnd(widths[index])).join("  ").trimEnd();
-    lines.push(renderRow(header));
-    lines.push(widths.map((width) => "-".repeat(width)).join("  ").trimEnd());
-    for (const row of rows) {
-      lines.push(renderRow(row));
-    }
-  }
-  lines.push("");
-  if (opts.notices.length === 0) {
-    lines.push("Notices: none.");
-  } else {
-    lines.push(`Notices (${opts.notices.length}):`);
-    for (const notice of opts.notices) {
-      lines.push(`- [${notice.kind}] ${notice.message}`);
-    }
-  }
-  return lines.join("\n");
-}
-async function readPackageVersion2() {
-  const moduleDir = dirname4(fileURLToPath3(import.meta.url));
-  let current = moduleDir;
-  while (true) {
-    const candidate = join5(current, "package.json");
-    if (await pathExists(candidate)) {
-      try {
-        const parsed = JSON.parse(await readFile11(candidate, "utf8"));
-        if (typeof parsed?.version === "string") {
-          return parsed.version;
-        }
-      } catch {
-      }
-    }
-    const parent = dirname4(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return "0.0.0";
-}
-
-// src/commands/status.ts
+import { Command as Command8 } from "commander";
 function statusCommand() {
-  return new Command7("status").description("Show installed weave-it package and skill version state.").option("--json", "print machine-readable JSON").action(async (options) => {
+  return new Command8("status").description("Show installed weave-it package and skill version state.").option("--json", "print machine-readable JSON").action(async (options) => {
     await withNotices(
       { commandName: "status", json: options.json ?? false },
       async () => {
@@ -3956,18 +4257,18 @@ function statusCommand() {
 }
 
 // src/commands/task.ts
-import { Command as Command8, InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { Command as Command9, InvalidArgumentError as InvalidArgumentError4 } from "commander";
 
 // src/lib/task-prepare.ts
 import { readFile as readFile13, writeFile as writeFile5 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 import YAML9 from "yaml";
 
 // src/lib/tasks.ts
 import { readFile as readFile12 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function loadTasksForChange(changePath) {
-  const tasksPath = path11.join(changePath, "tasks.md");
+  const tasksPath = path12.join(changePath, "tasks.md");
   if (!await pathExists(tasksPath)) {
     throw new ChangeCommandError("tasks_missing", "No tasks.md found for the active change. Run `weave-issues` first.", { path: tasksPath });
   }
@@ -4125,7 +4426,7 @@ async function workspaceModeTargets(rootPath, tasks, blockers) {
       blockers.push({ target: repoId, reason: "Task references a repo id that is not registered in workspace metadata." });
       continue;
     }
-    const absolutePath = path12.join(rootPath, entry.path);
+    const absolutePath = path13.join(rootPath, entry.path);
     if (!await pathExists(absolutePath)) {
       blockers.push({ target: repoId, reason: `Registered repo path does not exist: ${entry.path}` });
       continue;
@@ -4211,7 +4512,7 @@ async function applyPlans(plans, branch) {
   return repos;
 }
 async function writeExecutionState(changePath, branch, repos, now) {
-  const statusPath = path12.join(changePath, "status.yml");
+  const statusPath = path13.join(changePath, "status.yml");
   const raw = YAML9.parse(await readFile13(statusPath, "utf8"));
   const existingExecution = isRecord2(raw.execution) ? raw.execution : void 0;
   const existingBranch = typeof existingExecution?.branch === "string" ? existingExecution.branch : void 0;
@@ -4288,7 +4589,7 @@ function isRecord2(value) {
 
 // src/commands/task.ts
 function taskCommand() {
-  const command = new Command8("task").description("Prepare and inspect Weave local tasks.");
+  const command = new Command9("task").description("Prepare and inspect Weave local tasks.");
   command.command("prepare").description("Prepare local branches for selected tasks.").argument("[tasks...]", "task ids, e.g. T1 T3").option("--scope <scope>", "prepare repos referenced by tasks with this scope").option("--all", "prepare repos referenced by all T# tasks").option("--json", "print machine-readable JSON").action(async (tasks, options) => {
     await runAction5(options.json ?? false, async () => {
       const selector = parsePrepareSelector(tasks, options);
@@ -4364,10 +4665,10 @@ function errorResult3(error) {
 }
 
 // src/commands/workspace.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/lib/show-workspace.ts
-import path13 from "path";
+import path14 from "path";
 async function showWorkspace(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const sessionPath = options.sessionPath ?? defaultSessionPath();
@@ -4438,8 +4739,8 @@ function buildFolderOutput(id, folderPath, kind) {
     id,
     path: folderPath,
     kind,
-    wiki: path13.join(folderPath, "wiki"),
-    metadata: path13.join(folderPath, ".weave")
+    wiki: path14.join(folderPath, "wiki"),
+    metadata: path14.join(folderPath, ".weave")
   };
 }
 function sessionJson(session) {
@@ -4453,7 +4754,7 @@ function sessionJson(session) {
 }
 function workspaceSummary(workspacePath, metadata) {
   return {
-    name: metadata?.name ?? path13.basename(workspacePath),
+    name: metadata?.name ?? path14.basename(workspacePath),
     path: workspacePath,
     mode: "workspace"
   };
@@ -4462,7 +4763,7 @@ async function reposWithAvailability(workspacePath, repos) {
   return Promise.all(
     repos.map(async (repo) => ({
       ...repo,
-      availability: await pathExists(path13.join(workspacePath, repo.path)) ? "present" : "missing"
+      availability: await pathExists(path14.join(workspacePath, repo.path)) ? "present" : "missing"
     }))
   );
 }
@@ -4497,7 +4798,7 @@ Next:
 
 // src/commands/workspace.ts
 function workspaceCommand() {
-  return new Command9("workspace").description("Show the current Weave workspace (workspace mode) or session folders (repo mode).").option("--json", "print machine-readable JSON").action(async (options) => {
+  return new Command10("workspace").description("Show the current Weave workspace (workspace mode) or session folders (repo mode).").option("--json", "print machine-readable JSON").action(async (options) => {
     await withNotices(
       { commandName: "workspace", json: options.json ?? false },
       async () => {
@@ -4513,16 +4814,26 @@ function workspaceCommand() {
 }
 
 // src/cli.ts
-import { realpathSync } from "fs";
+import { readFileSync, realpathSync } from "fs";
+import path15 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
+function readPackageVersion3(moduleUrl = import.meta.url) {
+  const packageJsonPath = path15.join(path15.dirname(fileURLToPath4(moduleUrl)), "..", "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  if (typeof packageJson.version !== "string") {
+    throw new Error(`Missing version in ${packageJsonPath}`);
+  }
+  return packageJson.version;
+}
 function createProgram() {
-  const program = new Command10();
-  program.name("weave").description("Repo-local LLM wiki and temporary multi-folder AI session tooling.").version("0.1.0");
+  const program = new Command11();
+  program.name("weave").description("Repo-local LLM wiki and temporary multi-folder AI session tooling.").version(readPackageVersion3());
   program.addCommand(initCommand());
   program.addCommand(addCommand());
   program.addCommand(workspaceCommand());
   program.addCommand(changeCommand());
   program.addCommand(artifactCommand());
+  program.addCommand(doctorCommand());
   program.addCommand(agentCommand());
   program.addCommand(skillsCommand());
   program.addCommand(skillCommand());
@@ -4545,6 +4856,7 @@ if (isDirectCliInvocation()) {
 }
 export {
   createProgram,
-  isDirectCliInvocation
+  isDirectCliInvocation,
+  readPackageVersion3 as readPackageVersion
 };
 //# sourceMappingURL=cli.js.map