openspec-dashboard 0.1.0

package/dist/chunk-YBLVDJ3Y.js

@@ -0,0 +1,1232 @@
+// src/server/index.ts
+import express from "express";
+import http from "http";
+import path11 from "path";
+
+// src/server/routes/config.ts
+import { Router } from "express";
+import fs from "fs";
+import path from "path";
+import { spawn } from "child_process";
+function createConfigRouter({ getData, getOpenspecDir }) {
+  const router = Router();
+  router.get("/", (_req, res) => {
+    const openspecDir = getOpenspecDir();
+    if (!fs.existsSync(openspecDir)) {
+      res.json({
+        schema: "spec-driven",
+        defaultSchema: "spec-driven",
+        availableSchemas: [],
+        _notInitialized: true,
+        _message: "openspec \u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u5728\u9879\u76EE\u6839\u76EE\u5F55\u8FD0\u884C openspec \u521D\u59CB\u5316\u547D\u4EE4"
+      });
+      return;
+    }
+    res.json(getData().config);
+  });
+  router.get("/initialized", (_req, res) => {
+    const openspecDir = getOpenspecDir();
+    res.json({
+      initialized: fs.existsSync(openspecDir),
+      path: openspecDir
+    });
+  });
+  router.post("/init", async (req, res) => {
+    const openspecDir = getOpenspecDir();
+    const projectDir = path.dirname(openspecDir);
+    if (fs.existsSync(openspecDir)) {
+      res.status(400).json({ error: "OpenSpec \u5DF2\u521D\u59CB\u5316" });
+      return;
+    }
+    try {
+      await new Promise((resolve, reject) => {
+        const check = spawn("openspec", ["--version"], {
+          cwd: projectDir
+        });
+        check.on("close", (code) => {
+          if (code === 0) resolve();
+          else reject(new Error("openspec CLI not found"));
+        });
+        check.on("error", reject);
+      });
+    } catch {
+      res.status(400).json({
+        error: "\u672A\u5B89\u88C5 openspec CLI",
+        hint: "\u8BF7\u5148\u5B89\u88C5: npm install -g @fission-ai/openspec"
+      });
+      return;
+    }
+    const proc = spawn("openspec", ["init", "--tools", "claude"], {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        res.json({ status: "success", path: openspecDir });
+      } else {
+        res.status(500).json({ error: `\u521D\u59CB\u5316\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${code}` });
+      }
+    });
+    proc.on("error", (err) => {
+      res.status(500).json({ error: `\u521D\u59CB\u5316\u5931\u8D25: ${err.message}` });
+    });
+  });
+  return router;
+}
+
+// src/server/routes/changes.ts
+import { Router as Router2 } from "express";
+import fs6 from "fs";
+import path5 from "path";
+
+// src/server/parser/config-parser.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import yaml from "js-yaml";
+async function parseConfig(openspecDir) {
+  const configPath = path2.join(openspecDir, "config.yaml");
+  try {
+    const content = await fs2.readFile(configPath, "utf-8");
+    const raw = yaml.load(content);
+    return {
+      schema: raw?.schema ?? "spec-driven",
+      context: raw?.context,
+      defaultSchema: raw?.default_schema ?? raw?.schema ?? "spec-driven",
+      availableSchemas: []
+    };
+  } catch {
+    return {
+      schema: "spec-driven",
+      defaultSchema: "spec-driven",
+      availableSchemas: []
+    };
+  }
+}
+
+// src/server/parser/schema-parser.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import yaml2 from "js-yaml";
+async function parseSchemas(openspecDir) {
+  const schemasDir = path3.join(openspecDir, "schemas");
+  try {
+    const entries = await fs3.readdir(schemasDir, { withFileTypes: true });
+    const schemas = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const schemaPath = path3.join(schemasDir, entry.name, "schema.yaml");
+      try {
+        const content = await fs3.readFile(schemaPath, "utf-8");
+        const raw = yaml2.load(content);
+        schemas.push({
+          name: raw.name,
+          version: raw.version,
+          description: raw.description,
+          artifacts: raw.artifacts.map((a) => ({
+            id: a.id,
+            generates: a.generates,
+            description: a.description,
+            requires: a.requires ?? []
+          }))
+        });
+      } catch {
+      }
+    }
+    return schemas;
+  } catch {
+    return [];
+  }
+}
+
+// src/server/parser/change-parser.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+import yaml3 from "js-yaml";
+
+// src/server/parser/task-parser.ts
+import fs4 from "fs/promises";
+function parseTaskProgress(content) {
+  const checkboxRegex = /^- \[([ x])\]/gm;
+  let total = 0;
+  let completed = 0;
+  let match;
+  while ((match = checkboxRegex.exec(content)) !== null) {
+    total++;
+    if (match[1] === "x") completed++;
+  }
+  return { total, completed };
+}
+async function parseTaskProgressFromFile(filePath) {
+  try {
+    const content = await fs4.readFile(filePath, "utf-8");
+    return parseTaskProgress(content);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/server/parser/change-parser.ts
+function deriveChangeType(name) {
+  if (name.startsWith("feat-")) return "feat";
+  if (name.startsWith("fix-")) return "fix";
+  if (name.startsWith("hotfix-")) return "hotfix";
+  return "unknown";
+}
+function deriveDisplayName(name) {
+  const withoutPrefix = name.replace(/^(feat|fix|hotfix)-/, "");
+  return withoutPrefix.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function findSchema(schemaName, schemas) {
+  return schemas.find((s) => s.name === schemaName);
+}
+async function fileExists(filePath) {
+  try {
+    await fs5.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveArtifactStatus(changeDir, schema) {
+  const results = [];
+  for (const artifact of schema.artifacts) {
+    if (artifact.generates.includes("*")) {
+      const files = await findFiles(changeDir, artifact.generates);
+      results.push({
+        id: artifact.id,
+        status: files.length > 0 ? "done" : "pending",
+        filePath: files[0]
+      });
+    } else {
+      const filePath = path4.join(changeDir, artifact.generates);
+      const exists = await fileExists(filePath);
+      results.push({
+        id: artifact.id,
+        status: exists ? "done" : "pending",
+        filePath: exists ? filePath : void 0
+      });
+    }
+  }
+  return results;
+}
+async function findFiles(baseDir, pattern) {
+  const parts = pattern.split("/");
+  const results = [];
+  await walkForPattern(baseDir, parts, 0, results);
+  return results;
+}
+async function walkForPattern(dir, parts, idx, results) {
+  if (idx >= parts.length) return;
+  const part = parts[idx];
+  if (part === "**") {
+    await walkRecursive(dir, parts, idx + 1, results);
+  } else if (part.includes("*")) {
+    const regex = new RegExp("^" + part.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+    try {
+      const entries = await fs5.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && regex.test(entry.name) && idx === parts.length - 1) {
+          results.push(path4.join(dir, entry.name));
+        } else if (entry.isDirectory() && regex.test(entry.name)) {
+          await walkForPattern(path4.join(dir, entry.name), parts, idx + 1, results);
+        }
+      }
+    } catch {
+    }
+  } else {
+    const nextDir = path4.join(dir, part);
+    if (idx === parts.length - 1) {
+      if (await fileExists(nextDir)) results.push(nextDir);
+    } else {
+      await walkForPattern(nextDir, parts, idx + 1, results);
+    }
+  }
+}
+async function walkRecursive(dir, parts, nextIdx, results) {
+  try {
+    const entries = await fs5.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isFile()) {
+        if (nextIdx < parts.length) {
+          const regex = new RegExp("^" + parts[nextIdx].replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+          if (regex.test(entry.name) && nextIdx === parts.length - 1) {
+            results.push(fullPath);
+          }
+        }
+      } else if (entry.isDirectory()) {
+        if (nextIdx < parts.length && entry.name === parts[nextIdx]) {
+          await walkForPattern(fullPath, parts, nextIdx + 1, results);
+        }
+        await walkRecursive(fullPath, parts, nextIdx, results);
+      }
+    }
+  } catch {
+  }
+}
+function determineStatus(isArchived, hasDesign, hasProposal, hasTasks) {
+  if (isArchived) return "archived";
+  if (hasDesign && hasProposal && hasTasks) {
+    return "ready";
+  }
+  return "in_progress";
+}
+async function parseOneChange(changeDir, name, schemas, isArchived) {
+  const configPath = path4.join(changeDir, ".openspec.yaml");
+  let schemaName = "spec-driven";
+  let createdAt;
+  try {
+    const raw = yaml3.load(await fs5.readFile(configPath, "utf-8"));
+    schemaName = raw?.schema ?? "spec-driven";
+    createdAt = raw?.created;
+  } catch {
+  }
+  if (!createdAt) {
+    try {
+      const stats = await fs5.stat(changeDir);
+      createdAt = stats.birthtime.toISOString();
+    } catch {
+    }
+  }
+  const hasDesign = await fileExists(path4.join(changeDir, "design.md"));
+  const hasProposal = await fileExists(path4.join(changeDir, "proposal.md"));
+  const hasTasks = await fileExists(path4.join(changeDir, "tasks.md"));
+  const taskProgress = await parseTaskProgressFromFile(path4.join(changeDir, "tasks.md"));
+  const specsDir = path4.join(changeDir, "specs");
+  let applied = false;
+  try {
+    const specEntries = await fs5.readdir(specsDir, { withFileTypes: true });
+    const hasSpecDirs = specEntries.some((e) => e.isDirectory());
+    if (hasSpecDirs && taskProgress && taskProgress.completed >= taskProgress.total) {
+      applied = true;
+    }
+  } catch {
+  }
+  const defaultArtifacts = [
+    { id: "proposal", status: hasProposal ? "done" : "pending", filePath: hasProposal ? path4.join(changeDir, "proposal.md") : void 0 },
+    { id: "design", status: hasDesign ? "done" : "pending", filePath: hasDesign ? path4.join(changeDir, "design.md") : void 0 },
+    { id: "tasks", status: hasTasks ? "done" : "pending", filePath: hasTasks ? path4.join(changeDir, "tasks.md") : void 0 }
+  ];
+  const schema = findSchema(schemaName, schemas);
+  const artifacts = schema ? await resolveArtifactStatus(changeDir, schema) : defaultArtifacts;
+  return {
+    name,
+    displayName: deriveDisplayName(name),
+    type: deriveChangeType(name),
+    status: determineStatus(isArchived, hasDesign, hasProposal, hasTasks),
+    schema: schemaName,
+    artifacts,
+    taskProgress: taskProgress ?? void 0,
+    createdAt,
+    applied
+  };
+}
+async function parseChanges(openspecDir, schemas) {
+  const changesDir = path4.join(openspecDir, "changes");
+  const changes = [];
+  try {
+    const entries = await fs5.readdir(changesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === "archive") {
+        const archiveDir = path4.join(changesDir, "archive");
+        try {
+          const archiveEntries = await fs5.readdir(archiveDir, { withFileTypes: true });
+          for (const ae of archiveEntries) {
+            if (!ae.isDirectory()) continue;
+            const change2 = await parseOneChange(
+              path4.join(archiveDir, ae.name),
+              ae.name,
+              schemas,
+              true
+            );
+            changes.push(change2);
+          }
+        } catch {
+        }
+        continue;
+      }
+      const change = await parseOneChange(
+        path4.join(changesDir, entry.name),
+        entry.name,
+        schemas,
+        false
+      );
+      changes.push(change);
+    }
+  } catch {
+  }
+  return changes;
+}
+async function parseChangeDetail(openspecDir, name, schemas) {
+  const changesDir = path4.join(openspecDir, "changes");
+  let changeDir = path4.join(changesDir, name);
+  if (!await fileExists(changeDir)) {
+    changeDir = path4.join(changesDir, "archive", name);
+    if (!await fileExists(changeDir)) return null;
+  }
+  const isArchived = changeDir.includes("/archive/");
+  const change = await parseOneChange(changeDir, name, schemas, isArchived);
+  const artifactContents = {};
+  for (const artifact of change.artifacts) {
+    if (artifact.filePath && artifact.status === "done") {
+      try {
+        artifactContents[artifact.id] = await fs5.readFile(artifact.filePath, "utf-8");
+      } catch {
+      }
+    }
+  }
+  const specFiles = [];
+  const specsDir = path4.join(changeDir, "specs");
+  try {
+    const specEntries = await fs5.readdir(specsDir, { withFileTypes: true });
+    for (const entry of specEntries) {
+      if (!entry.isDirectory()) continue;
+      const specPath = path4.join(specsDir, entry.name, "spec.md");
+      try {
+        const content = await fs5.readFile(specPath, "utf-8");
+        specFiles.push({ capability: entry.name, filePath: specPath, content });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { ...change, artifactContents, specFiles };
+}
+
+// src/server/parser/index.ts
+async function loadProjectData(openspecDir) {
+  const [config, schemas] = await Promise.all([
+    parseConfig(openspecDir),
+    parseSchemas(openspecDir)
+  ]);
+  config.availableSchemas = schemas;
+  const changes = await parseChanges(openspecDir, schemas);
+  return { config, schemas, changes };
+}
+async function loadChangeDetail(openspecDir, name, schemas) {
+  return parseChangeDetail(openspecDir, name, schemas);
+}
+
+// src/server/routes/changes.ts
+function createChangesRouter(getData, getOpenspecDir) {
+  const router = Router2();
+  router.get("/", (_req, res) => {
+    res.json(getData().changes);
+  });
+  router.get("/:name", async (req, res) => {
+    const { name } = req.params;
+    const detail = await loadChangeDetail(getOpenspecDir(), name, getData().schemas);
+    if (!detail) {
+      res.status(404).json({ error: "Change not found" });
+      return;
+    }
+    res.json(detail);
+  });
+  router.post("/batch-archive", async (req, res) => {
+    const { names } = req.body;
+    if (!Array.isArray(names) || names.length === 0) {
+      res.status(400).json({ error: "names must be a non-empty array" });
+      return;
+    }
+    const openspecDir = getOpenspecDir();
+    const changesDir = path5.join(openspecDir, "changes");
+    const archiveDir = path5.join(changesDir, "archive");
+    const results = [];
+    for (const name of names) {
+      const changeDir = path5.join(changesDir, name);
+      const archiveTarget = path5.join(archiveDir, name);
+      try {
+        if (!fs6.existsSync(changeDir)) {
+          results.push({ name, success: false, error: "Change directory not found" });
+          continue;
+        }
+        if (fs6.existsSync(archiveTarget)) {
+          results.push({ name, success: false, error: "Already archived" });
+          continue;
+        }
+        fs6.mkdirSync(archiveDir, { recursive: true });
+        fs6.renameSync(changeDir, archiveTarget);
+        results.push({ name, success: true });
+      } catch (err) {
+        results.push({ name, success: false, error: String(err) });
+      }
+    }
+    const allSuccess = results.every((r) => r.success);
+    res.status(allSuccess ? 200 : 207).json({ results });
+  });
+  router.post("/batch-unarchive", async (req, res) => {
+    const { names } = req.body;
+    if (!Array.isArray(names) || names.length === 0) {
+      res.status(400).json({ error: "names must be a non-empty array" });
+      return;
+    }
+    const openspecDir = getOpenspecDir();
+    const changesDir = path5.join(openspecDir, "changes");
+    const archiveDir = path5.join(changesDir, "archive");
+    const results = [];
+    for (const name of names) {
+      const archiveSource = path5.join(archiveDir, name);
+      const changeTarget = path5.join(changesDir, name);
+      try {
+        if (!fs6.existsSync(archiveSource)) {
+          results.push({ name, success: false, error: "Archived change not found" });
+          continue;
+        }
+        if (fs6.existsSync(changeTarget)) {
+          results.push({ name, success: false, error: "Change already exists" });
+          continue;
+        }
+        fs6.renameSync(archiveSource, changeTarget);
+        results.push({ name, success: true });
+      } catch (err) {
+        results.push({ name, success: false, error: String(err) });
+      }
+    }
+    const allSuccess = results.every((r) => r.success);
+    res.status(allSuccess ? 200 : 207).json({ results });
+  });
+  return router;
+}
+
+// src/server/routes/schemas.ts
+import { Router as Router3 } from "express";
+function createSchemasRouter(getData) {
+  const router = Router3();
+  router.get("/", (_req, res) => {
+    res.json(getData().schemas);
+  });
+  return router;
+}
+
+// src/server/routes/skills.ts
+import { Router as Router4 } from "express";
+import fs7 from "fs";
+import path6 from "path";
+import matter from "gray-matter";
+function createSkillsRouter(getProjectDir) {
+  const router = Router4();
+  router.get("/", (_req, res) => {
+    const opsxDir = path6.join(getProjectDir(), ".claude", "commands", "opsx");
+    const skills = [];
+    try {
+      const entries = fs7.readdirSync(opsxDir);
+      for (const entry of entries) {
+        if (!entry.endsWith(".md")) continue;
+        const filePath = path6.join(opsxDir, entry);
+        try {
+          const raw = fs7.readFileSync(filePath, "utf-8");
+          const { data } = matter(raw);
+          skills.push({
+            id: entry.replace(".md", ""),
+            name: data.name || entry.replace(".md", ""),
+            description: data.description || "",
+            category: data.category || "",
+            tags: data.tags || []
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+    res.json(skills);
+  });
+  return router;
+}
+
+// src/server/routes/execution.ts
+import { Router as Router5 } from "express";
+import fs8 from "fs";
+import path7 from "path";
+var IDLE_STATE = {
+  skill: "",
+  change: "",
+  status: "idle",
+  phase: "creating_artifact",
+  currentTask: 0,
+  totalTasks: 0,
+  currentArtifact: null,
+  startedAt: "",
+  updatedAt: ""
+};
+function createExecutionRouter(getOpenspecDir, executor) {
+  const router = Router5();
+  router.get("/", (_req, res) => {
+    const execPath = path7.join(getOpenspecDir(), "execution.json");
+    try {
+      const raw = fs8.readFileSync(execPath, "utf-8");
+      const state = JSON.parse(raw);
+      res.json(state);
+    } catch {
+      res.json(IDLE_STATE);
+    }
+  });
+  router.get("/log", (_req, res) => {
+    const logPath = path7.join(getOpenspecDir(), "execution.log");
+    try {
+      const raw = fs8.readFileSync(logPath, "utf-8");
+      const lines = raw.split("\n").filter(Boolean);
+      const entries = lines.map((line) => ({
+        line,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      res.json(entries);
+    } catch {
+      res.json([]);
+    }
+  });
+  router.post("/start", async (req, res) => {
+    if (!executor) {
+      res.status(501).json({ error: "Executor not available" });
+      return;
+    }
+    const { skill, change, note } = req.body;
+    if (!skill || !change) {
+      res.status(400).json({ error: "skill and change are required" });
+      return;
+    }
+    if (executor.getStatus().isRunning) {
+      res.status(409).json({ error: "Another skill is already running" });
+      return;
+    }
+    executor.execute(skill, change, note).catch(() => {
+    });
+    res.json({ status: "started", skill, change });
+  });
+  router.post("/cancel", (_req, res) => {
+    if (!executor) {
+      res.status(501).json({ error: "Executor not available" });
+      return;
+    }
+    const cancelled = executor.cancel();
+    if (cancelled) {
+      res.json({ status: "cancelled" });
+    } else {
+      res.status(404).json({ error: "No running skill to cancel" });
+    }
+  });
+  router.post("/input", (req, res) => {
+    if (!executor) {
+      res.status(501).json({ error: "Executor not available" });
+      return;
+    }
+    const { input } = req.body;
+    if (!input || typeof input !== "string") {
+      res.status(400).json({ success: false, error: "input is required" });
+      return;
+    }
+    const result = executor.sendInput(input);
+    if (result.success) {
+      res.json({ success: true });
+    } else {
+      res.status(400).json({ success: false, error: result.error });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/projects.ts
+import { Router as Router6 } from "express";
+import fs9 from "fs/promises";
+import path8 from "path";
+import yaml4 from "js-yaml";
+var SCAN_DIRS = ["/home/zw/project"];
+async function discoverProjects(scanDirs) {
+  const projects = [];
+  for (const scanDir of scanDirs) {
+    let entries;
+    try {
+      entries = await fs9.readdir(scanDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const projectPath = path8.join(scanDir, entry);
+      const openspecPath = path8.join(projectPath, "openspec");
+      try {
+        const stat = await fs9.stat(projectPath);
+        if (!stat.isDirectory()) continue;
+        const openspecStat = await fs9.stat(openspecPath);
+        if (!openspecStat.isDirectory()) continue;
+        const name = await getProjectName(openspecPath, entry);
+        projects.push({ name, path: projectPath, available: true });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return projects;
+}
+async function getProjectName(openspecDir, fallback) {
+  try {
+    const configPath = path8.join(openspecDir, "config.yaml");
+    const content = await fs9.readFile(configPath, "utf-8");
+    const raw = yaml4.load(content);
+    return raw?.project?.name || fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function validateProjectPath(projectPath) {
+  try {
+    const openspecPath = path8.join(projectPath, "openspec");
+    const stat = await fs9.stat(openspecPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function createProjectsRouter(getOpenspecDir, switchProject) {
+  const router = Router6();
+  router.get("/", async (_req, res) => {
+    const projects = await discoverProjects(SCAN_DIRS);
+    const openspecDir = getOpenspecDir();
+    const currentProjectPath = path8.resolve(openspecDir, "..");
+    const currentInList = projects.some((p) => p.path === currentProjectPath);
+    if (!currentInList) {
+      try {
+        await fs9.access(openspecDir);
+        const name = await getProjectName(openspecDir, path8.basename(currentProjectPath));
+        projects.unshift({ name, path: currentProjectPath, available: true });
+      } catch {
+        projects.unshift({ name: path8.basename(currentProjectPath), path: currentProjectPath, available: false });
+      }
+    }
+    res.json(projects);
+  });
+  router.post("/switch", async (req, res) => {
+    const { path: projectPath } = req.body;
+    if (!projectPath || typeof projectPath !== "string") {
+      res.status(400).json({ error: "path is required" });
+      return;
+    }
+    const valid = await validateProjectPath(projectPath);
+    if (!valid) {
+      res.status(400).json({ error: "Invalid project path: no openspec/ directory found" });
+      return;
+    }
+    try {
+      await switchProject(projectPath);
+      res.json({ status: "ok", path: projectPath });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/server/watcher.ts
+import chokidar from "chokidar";
+import fs10 from "fs";
+import path9 from "path";
+function parseTaskProgress2(line) {
+  const patterns = [
+    /[Tt]ask\s+(\d+)\/(\d+)/,
+    /(\d+)\/(\d+)/,
+    /[Tt]ask\s+(\d+)\s+of\s+(\d+)/,
+    /\[(\d+)\/(\d+)\]/
+  ];
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      return { current: parseInt(match[1], 10), total: parseInt(match[2], 10) };
+    }
+  }
+  return null;
+}
+function createWatcher(options) {
+  const { onChange, debounceMs = 500, onSkillProgress, onSkillLog } = options;
+  let timeout = null;
+  let lastLogSize = 0;
+  let lastState = null;
+  let currentDir = options.openspecDir;
+  const debouncedChange = () => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(onChange, debounceMs);
+  };
+  const isExecutionFile = (filePath) => {
+    return filePath.endsWith("execution.json") || filePath.endsWith("execution.log");
+  };
+  const handleExecutionChange = (filePath) => {
+    if (filePath.endsWith("execution.json") && onSkillProgress) {
+      try {
+        const raw = fs10.readFileSync(filePath, "utf-8");
+        const state = JSON.parse(raw);
+        onSkillProgress(state);
+      } catch {
+      }
+    }
+    if (filePath.endsWith("execution.log") && onSkillLog) {
+      try {
+        const stat = fs10.statSync(filePath);
+        if (stat.size > lastLogSize) {
+          const raw = fs10.readFileSync(filePath, "utf-8");
+          const newContent = raw.substring(lastLogSize);
+          lastLogSize = stat.size;
+          const lines = newContent.split("\n").filter(Boolean);
+          for (const line of lines) {
+            onSkillLog(line);
+            if (onSkillProgress && lastState && lastState.status === "running") {
+              const progress = parseTaskProgress2(line);
+              if (progress && (progress.current !== lastState.currentTask || progress.total !== lastState.totalTasks)) {
+                const updatedState = {
+                  ...lastState,
+                  currentTask: progress.current,
+                  totalTasks: progress.total,
+                  updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+                };
+                lastState = updatedState;
+                const execPath = path9.join(currentDir, "execution.json");
+                fs10.writeFileSync(execPath, JSON.stringify(updatedState, null, 2) + "\n");
+                onSkillProgress(updatedState);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  const setupHandlers = (watcher2) => {
+    watcher2.on("add", (filePath) => {
+      if (isExecutionFile(filePath)) {
+        handleExecutionChange(filePath);
+        return;
+      }
+      if (isRelevantFile(filePath)) debouncedChange();
+    });
+    watcher2.on("change", (filePath) => {
+      if (isExecutionFile(filePath)) {
+        handleExecutionChange(filePath);
+        return;
+      }
+      if (isRelevantFile(filePath)) debouncedChange();
+    });
+    watcher2.on("unlink", (filePath) => {
+      if (isExecutionFile(filePath)) return;
+      if (isRelevantFile(filePath)) debouncedChange();
+    });
+  };
+  let watcher = chokidar.watch([
+    currentDir,
+    path9.join(currentDir, "execution.json"),
+    path9.join(currentDir, "execution.log")
+  ], {
+    ignored: [
+      /(^|[\/\\])\../,
+      "**/node_modules/**"
+    ],
+    persistent: true,
+    ignoreInitial: true
+  });
+  setupHandlers(watcher);
+  return {
+    close: () => {
+      if (timeout) clearTimeout(timeout);
+      return watcher.close();
+    },
+    async switchDir(newOpenspecDir) {
+      if (timeout) clearTimeout(timeout);
+      lastLogSize = 0;
+      lastState = null;
+      await watcher.close();
+      currentDir = newOpenspecDir;
+      watcher = chokidar.watch([
+        currentDir,
+        path9.join(currentDir, "execution.json"),
+        path9.join(currentDir, "execution.log")
+      ], {
+        ignored: [
+          /(^|[\/\\])\../,
+          "**/node_modules/**"
+        ],
+        persistent: true,
+        ignoreInitial: true
+      });
+      setupHandlers(watcher);
+      console.log(`Watcher switched to: ${currentDir}`);
+    },
+    getCurrentDir() {
+      return currentDir;
+    }
+  };
+}
+function isRelevantFile(filePath) {
+  const ext = path9.extname(filePath);
+  return ext === ".md" || ext === ".yaml" || ext === ".yml";
+}
+
+// src/server/ws.ts
+import { WebSocketServer, WebSocket } from "ws";
+function createWebSocketServer(server) {
+  const wss = new WebSocketServer({ server, path: "/ws/changes" });
+  const broadcast = (data) => {
+    const message = JSON.stringify(data);
+    wss.clients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    });
+  };
+  return { wss, broadcast };
+}
+
+// src/server/executor.ts
+import { spawn as spawn2 } from "child_process";
+import fs11 from "fs";
+import path10 from "path";
+var IDLE_STATE2 = {
+  skill: "",
+  change: "",
+  status: "idle",
+  phase: "creating_artifact",
+  currentTask: 0,
+  totalTasks: 0,
+  currentArtifact: null,
+  startedAt: "",
+  updatedAt: ""
+};
+var SkillExecutor = class {
+  openspecDir;
+  projectDir;
+  broadcast;
+  currentProcess = null;
+  currentStdin = null;
+  currentSkill = "";
+  currentChange = "";
+  constructor(options) {
+    this.openspecDir = options.openspecDir;
+    this.projectDir = options.projectDir;
+    this.broadcast = options.broadcast;
+  }
+  async execute(skill, change, note) {
+    if (this.currentProcess) {
+      throw new Error("Another skill is already running");
+    }
+    this.currentSkill = skill;
+    this.currentChange = change;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const state = {
+      skill,
+      change,
+      status: "running",
+      phase: skill === "apply" ? "implementing" : "creating_artifact",
+      currentTask: 0,
+      totalTasks: 0,
+      currentArtifact: null,
+      startedAt: now,
+      updatedAt: now
+    };
+    this.writeState(state);
+    this.clearLog();
+    this.appendLog(`Starting /opsx:${skill} ${change}`);
+    this.broadcast({ type: "skill_progress", data: state });
+    this.broadcast({ type: "skill_log", data: { line: `[${this.timestamp()}] Starting /opsx:${skill} ${change}`, timestamp: now } });
+    let prompt = `/opsx:${skill} ${change}`;
+    if (note) {
+      prompt += `
+
+\u7528\u6237\u5907\u6CE8\uFF1A${note}`;
+    }
+    return new Promise((resolve, reject) => {
+      const proc = spawn2("claude", [
+        "-p",
+        prompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--allowedTools",
+        "Bash,Read,Write,Edit,MCP"
+      ], {
+        cwd: this.projectDir,
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      this.currentProcess = proc;
+      this.currentStdin = proc.stdin;
+      let buffer = "";
+      proc.stdout.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            this.handleStreamEvent(event);
+          } catch {
+            this.appendLog(line);
+            this.broadcast({ type: "skill_log", data: { line, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+          }
+        }
+      });
+      proc.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        this.appendLog(text);
+        this.broadcast({ type: "skill_log", data: { line: text.trim(), timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+      });
+      proc.on("close", (code) => {
+        this.currentProcess = null;
+        this.currentStdin = null;
+        const currentState = this.readState();
+        if (code === 0 && currentState.status === "running") {
+          const completed = {
+            ...currentState,
+            status: "completed",
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.writeState(completed);
+          this.appendLog(`\u2713 /opsx:${skill} completed`);
+          this.broadcast({ type: "skill_complete", data: completed });
+          this.broadcast({ type: "skill_log", data: { line: `[${this.timestamp()}] \u2713 /opsx:${skill} completed`, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+          this.broadcast({ type: "refresh" });
+        } else if (code !== 0) {
+          const failed = {
+            ...currentState,
+            status: "failed",
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.writeState(failed);
+          this.appendLog(`\u2717 /opsx:${skill} failed (exit code ${code})`);
+          this.broadcast({ type: "skill_complete", data: failed });
+          this.broadcast({ type: "skill_log", data: { line: `[${this.timestamp()}] \u2717 /opsx:${skill} failed (exit code ${code})`, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+        }
+        resolve();
+      });
+      proc.on("error", (err) => {
+        this.currentProcess = null;
+        this.currentStdin = null;
+        const failed = {
+          ...this.readState(),
+          status: "failed",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.writeState(failed);
+        this.appendLog(`\u2717 Failed to start: ${err.message}`);
+        this.broadcast({ type: "skill_complete", data: failed });
+        reject(err);
+      });
+    });
+  }
+  cancel() {
+    if (!this.currentProcess) return false;
+    this.currentProcess.kill("SIGTERM");
+    this.currentProcess = null;
+    this.currentStdin = null;
+    const state = this.readState();
+    const cancelled = {
+      ...state,
+      status: "failed",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeState(cancelled);
+    this.appendLog(`\u2717 /opsx:${this.currentSkill} cancelled by user`);
+    this.broadcast({ type: "skill_complete", data: cancelled });
+    return true;
+  }
+  isRunning() {
+    return this.currentProcess !== null;
+  }
+  sendInput(text) {
+    if (!this.currentProcess || !this.currentStdin) {
+      return { success: false, error: "\u8FDB\u7A0B\u672A\u8FD0\u884C" };
+    }
+    try {
+      this.currentStdin.write(text + "\n");
+      this.appendLog(`[\u7528\u6237\u8F93\u5165] ${text}`);
+      this.broadcast({ type: "skill_log", data: { line: `[\u7528\u6237\u8F93\u5165] ${text}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: "\u65E0\u6CD5\u53D1\u9001\u8F93\u5165" };
+    }
+  }
+  getStatus() {
+    return {
+      isRunning: this.currentProcess !== null,
+      skill: this.currentSkill,
+      change: this.currentChange
+    };
+  }
+  updateBroadcast(broadcast) {
+    this.broadcast = broadcast;
+  }
+  updateDirs(openspecDir, projectDir) {
+    this.openspecDir = openspecDir;
+    this.projectDir = projectDir;
+  }
+  handleStreamEvent(event) {
+    const type = event.type;
+    if (type === "assistant") {
+      const message = event.message;
+      const content = message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "text" && typeof block.text === "string") {
+            const lines = block.text.split("\n").filter(Boolean);
+            for (const line of lines) {
+              this.appendLog(line);
+              this.broadcast({ type: "skill_log", data: { line, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+            }
+          }
+          if (block.type === "tool_use") {
+            const inputStr = block.input ? JSON.stringify(block.input) : "";
+            const toolLine = `\u2192 ${block.name} ${inputStr}`;
+            this.appendLog(toolLine);
+            this.broadcast({ type: "skill_log", data: { line: toolLine, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+          }
+        }
+      }
+    }
+    if (type === "tool_result") {
+      const result = event.result;
+      if (result) {
+        const displayResult = result.length > 300 ? result.substring(0, 300) + "\n  ... (\u5DF2\u622A\u65AD)" : result;
+        this.appendLog(displayResult);
+        this.broadcast({ type: "skill_log", data: { line: displayResult, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+      }
+    }
+    if (type === "result") {
+      const resultText = event.result;
+      if (resultText) {
+        this.appendLog(resultText);
+        this.broadcast({ type: "skill_log", data: { line: resultText, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+      }
+    }
+  }
+  timestamp() {
+    return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false });
+  }
+  statePath() {
+    return path10.join(this.openspecDir, "execution.json");
+  }
+  logPath() {
+    return path10.join(this.openspecDir, "execution.log");
+  }
+  readState() {
+    try {
+      const raw = fs11.readFileSync(this.statePath(), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { ...IDLE_STATE2 };
+    }
+  }
+  writeState(state) {
+    fs11.writeFileSync(this.statePath(), JSON.stringify(state, null, 2) + "\n");
+  }
+  clearLog() {
+    try {
+      fs11.unlinkSync(this.logPath());
+    } catch {
+    }
+  }
+  appendLog(line) {
+    const timestamp = this.timestamp();
+    const entry = `[${timestamp}] ${line}
+`;
+    try {
+      fs11.appendFileSync(this.logPath(), entry);
+    } catch {
+    }
+  }
+};
+
+// src/server/index.ts
+async function createServer(options) {
+  const app = express();
+  app.use(express.json());
+  const projectData = await loadProjectData(options.openspecDir);
+  const projectDir = options.projectDir || path11.resolve(options.openspecDir, "..");
+  let openspecDir = options.openspecDir;
+  app.use("/api/config", createConfigRouter({ getData: () => projectData, getOpenspecDir: () => openspecDir }));
+  app.use("/api/changes", createChangesRouter(() => projectData, () => openspecDir));
+  app.use("/api/schemas", createSchemasRouter(() => projectData));
+  app.use("/api/skills", createSkillsRouter(() => projectDir));
+  app.use("/api/execution", createExecutionRouter(() => openspecDir));
+  app.use("/api/projects", createProjectsRouter(() => openspecDir, async () => {
+  }));
+  if (options.staticDir) {
+    app.use(express.static(options.staticDir));
+    app.get("*", (_req, res) => {
+      res.sendFile(path11.join(options.staticDir, "index.html"));
+    });
+  }
+  return { app, refreshData: () => Promise.resolve() };
+}
+async function startServer(options) {
+  const server = http.createServer();
+  const { broadcast } = createWebSocketServer(server);
+  let currentOpenspecDir = options.openspecDir;
+  let currentProjectDir = options.projectDir || path11.resolve(options.openspecDir, "..");
+  const executor = new SkillExecutor({
+    openspecDir: currentOpenspecDir,
+    projectDir: currentProjectDir,
+    broadcast
+  });
+  const app = express();
+  app.use(express.json());
+  let projectData = await loadProjectData(currentOpenspecDir);
+  const refreshData = async () => {
+    projectData = await loadProjectData(currentOpenspecDir);
+  };
+  app.use("/api/config", createConfigRouter({ getData: () => projectData, getOpenspecDir: () => currentOpenspecDir }));
+  app.use("/api/changes", createChangesRouter(() => projectData, () => currentOpenspecDir));
+  app.use("/api/schemas", createSchemasRouter(() => projectData));
+  app.use("/api/skills", createSkillsRouter(() => currentProjectDir));
+  app.use("/api/execution", createExecutionRouter(() => currentOpenspecDir, executor));
+  const switchProject = async (newProjectPath) => {
+    const oldPath = currentProjectDir;
+    currentProjectDir = newProjectPath;
+    currentOpenspecDir = path11.join(newProjectPath, "openspec");
+    console.log(`Switching project from ${oldPath} to ${newProjectPath}`);
+    executor.updateDirs(currentOpenspecDir, currentProjectDir);
+    await watcher.switchDir(currentOpenspecDir);
+    await refreshData();
+    broadcast({ type: "refresh" });
+  };
+  app.use("/api/projects", createProjectsRouter(() => currentOpenspecDir, switchProject));
+  if (options.staticDir) {
+    app.use(express.static(options.staticDir));
+    app.get("*", (_req, res) => {
+      res.sendFile(path11.join(options.staticDir, "index.html"));
+    });
+  }
+  server.on("request", app);
+  const watcher = createWatcher({
+    openspecDir: currentOpenspecDir,
+    onChange: async () => {
+      await refreshData().catch((err) => console.error("Failed to refresh project data:", err));
+      broadcast({ type: "refresh" });
+    },
+    onSkillProgress: (state) => {
+      if (state.status === "completed" || state.status === "failed") {
+        broadcast({ type: "skill_complete", data: state });
+      } else {
+        broadcast({ type: "skill_progress", data: state });
+      }
+    },
+    onSkillLog: (line) => {
+      broadcast({ type: "skill_log", data: { line, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+    }
+  });
+  server.listen(options.port, () => {
+    console.log(`OpenSpec Dashboard running at http://localhost:${options.port}`);
+  });
+  const shutdown = async () => {
+    await watcher.close();
+    if (executor.getStatus().isRunning) {
+      executor.cancel();
+    }
+    server.close();
+  };
+  return { server, shutdown };
+}
+if (process.argv[1]?.includes("server/index")) {
+  const port = parseInt(process.env.PORT || "3456", 10);
+  const openspecDir = path11.resolve(process.cwd(), "openspec");
+  startServer({ openspecDir, port }).catch(console.error);
+}
+
+export {
+  createServer,
+  startServer
+};