spets 0.1.86 → 0.1.88

package/dist/chunk-5MG5ZRBD.js

@@ -0,0 +1,164 @@
+import {
+  clearConfigCache,
+  getConfigPath,
+  loadConfig
+} from "./chunk-VQV22N3Y.js";
+
+// src/ui/sections/config.ts
+import { writeFileSync } from "fs";
+import { spawnSync } from "child_process";
+import { select, input, confirm } from "@inquirer/prompts";
+import { stringify as yamlStringify } from "yaml";
+function getEditableFields() {
+  return [
+    { field: "steps", type: "array", description: "Workflow steps (ordered list)" },
+    { field: "output.path", type: "string", description: "Output directory path" },
+    { field: "knowledge.enabled", type: "boolean", description: "Enable knowledge saving" },
+    { field: "knowledge.inject", type: "boolean", description: "Inject knowledge into prompts" },
+    { field: "github.owner", type: "string", description: "GitHub repository owner" },
+    { field: "github.repo", type: "string", description: "GitHub repository name" }
+  ];
+}
+function renderConfigJSON(cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  const response = {
+    section: "config",
+    data: config,
+    editableFields: getEditableFields(),
+    actions: ["set", "edit"]
+  };
+  return JSON.stringify(response, null, 2);
+}
+function setConfigField(field, value, cwd = process.cwd()) {
+  try {
+    const configPath = getConfigPath(cwd);
+    const config = loadConfig(cwd);
+    let parsedValue;
+    try {
+      parsedValue = JSON.parse(value);
+    } catch {
+      parsedValue = value;
+    }
+    const parts = field.split(".");
+    let current = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!(part in current) || typeof current[part] !== "object") {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    current[parts[parts.length - 1]] = parsedValue;
+    const yamlContent = yamlStringify(config);
+    writeFileSync(configPath, yamlContent);
+    clearConfigCache();
+    return { success: true, message: `Set ${field} = ${JSON.stringify(parsedValue)}` };
+  } catch (error) {
+    return { success: false, message: `Failed to set ${field}: ${error.message}` };
+  }
+}
+function openConfigInEditor(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const result = spawnSync(editor, [configPath], {
+    stdio: "inherit",
+    shell: true
+  });
+  if (result.status === 0) {
+    clearConfigCache();
+    return { success: true, message: "Config edited successfully" };
+  } else {
+    return { success: false, message: `Editor exited with code ${result.status}` };
+  }
+}
+async function runConfigInteractive(cwd = process.cwd()) {
+  while (true) {
+    const config = loadConfig(cwd);
+    const action = await select({
+      message: "Config Management",
+      choices: [
+        { value: "view", name: "\u{1F4CB} View current config" },
+        { value: "steps", name: "\u{1F4DD} Edit steps" },
+        { value: "output", name: "\u{1F4C1} Edit output path" },
+        { value: "knowledge", name: "\u{1F9E0} Edit knowledge settings" },
+        { value: "github", name: "\u{1F419} Edit GitHub settings" },
+        { value: "edit", name: "\u270F\uFE0F  Open in editor" },
+        { value: "back", name: "\u2190 Back to main menu" }
+      ]
+    });
+    if (action === "back") {
+      break;
+    }
+    if (action === "view") {
+      console.log("\nCurrent Config:");
+      console.log(JSON.stringify(config, null, 2));
+      console.log();
+      continue;
+    }
+    if (action === "edit") {
+      const result = openConfigInEditor(cwd);
+      console.log(result.message);
+      continue;
+    }
+    if (action === "steps") {
+      const currentSteps = config.steps.join(", ");
+      const newSteps = await input({
+        message: "Enter steps (comma-separated):",
+        default: currentSteps
+      });
+      const stepsArray = newSteps.split(",").map((s) => s.trim()).filter(Boolean);
+      const result = setConfigField("steps", JSON.stringify(stepsArray), cwd);
+      console.log(result.message);
+      continue;
+    }
+    if (action === "output") {
+      const currentPath = config.output?.path || ".spets/outputs";
+      const newPath = await input({
+        message: "Output directory path:",
+        default: currentPath
+      });
+      const result = setConfigField("output.path", JSON.stringify(newPath), cwd);
+      console.log(result.message);
+      continue;
+    }
+    if (action === "knowledge") {
+      const enabled = await confirm({
+        message: "Enable knowledge saving?",
+        default: config.knowledge?.enabled ?? true
+      });
+      setConfigField("knowledge.enabled", JSON.stringify(enabled), cwd);
+      const inject = await confirm({
+        message: "Inject knowledge into prompts?",
+        default: config.knowledge?.inject ?? true
+      });
+      const result = setConfigField("knowledge.inject", JSON.stringify(inject), cwd);
+      console.log(result.message);
+      continue;
+    }
+    if (action === "github") {
+      const owner = await input({
+        message: "GitHub owner:",
+        default: config.github?.owner || ""
+      });
+      if (owner) {
+        setConfigField("github.owner", JSON.stringify(owner), cwd);
+      }
+      const repo = await input({
+        message: "GitHub repo:",
+        default: config.github?.repo || ""
+      });
+      if (repo) {
+        const result = setConfigField("github.repo", JSON.stringify(repo), cwd);
+        console.log(result.message);
+      }
+      continue;
+    }
+  }
+}
+
+export {
+  renderConfigJSON,
+  setConfigField,
+  openConfigInEditor,
+  runConfigInteractive
+};

package/dist/chunk-DVDS7BTW.js

@@ -0,0 +1,542 @@
+import {
+  getOutputsDir,
+  loadConfig,
+  spetsExists
+} from "./chunk-VQV22N3Y.js";
+
+// src/ui/sections/tasks.ts
+import { select as select2 } from "@inquirer/prompts";
+
+// src/core/state.ts
+import { readFileSync, existsSync, readdirSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import matter from "gray-matter";
+
+// src/core/slug.ts
+function generateRandomSuffix() {
+  return Math.random().toString(36).substring(2, 6);
+}
+function generateDatePrefix() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function sanitizeDescription(description) {
+  let sanitized = description.toLowerCase();
+  sanitized = sanitized.replace(/[^\x00-\x7F]/g, "");
+  sanitized = sanitized.replace(/[^a-z0-9\s]/g, "");
+  sanitized = sanitized.trim();
+  sanitized = sanitized.replace(/\s+/g, " ");
+  sanitized = sanitized.replace(/\s+/g, "-");
+  if (sanitized.length > 10) {
+    sanitized = sanitized.substring(0, 10);
+  }
+  sanitized = sanitized.replace(/-+$/, "");
+  if (sanitized === "") {
+    sanitized = "task";
+  }
+  return sanitized;
+}
+function generateSlug(description) {
+  const datePrefix = generateDatePrefix();
+  const meaningfulName = sanitizeDescription(description);
+  const randomSuffix = generateRandomSuffix();
+  return `${datePrefix}-${meaningfulName}-${randomSuffix}`;
+}
+
+// src/core/state.ts
+function generateTaskId(description) {
+  if (description) {
+    return generateSlug(description);
+  }
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 6);
+  return `${timestamp}-${random}`;
+}
+function getTaskDir(taskId, cwd = process.cwd()) {
+  return join(getOutputsDir(cwd), taskId);
+}
+function getOutputPath(taskId, stepName, cwd = process.cwd()) {
+  return join(getTaskDir(taskId, cwd), `${stepName}.md`);
+}
+function loadDocument(taskId, stepName, cwd = process.cwd()) {
+  const outputPath = getOutputPath(taskId, stepName, cwd);
+  if (!existsSync(outputPath)) {
+    return null;
+  }
+  const raw = readFileSync(outputPath, "utf-8");
+  const { content, data } = matter(raw);
+  return {
+    content,
+    frontmatter: data
+  };
+}
+function listTasks(cwd = process.cwd()) {
+  const outputsDir = getOutputsDir(cwd);
+  if (!existsSync(outputsDir)) {
+    return [];
+  }
+  return readdirSync(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+}
+function getWorkflowState(taskId, config, cwd = process.cwd()) {
+  const taskDir = getTaskDir(taskId, cwd);
+  if (!existsSync(taskDir)) {
+    return null;
+  }
+  const outputs = /* @__PURE__ */ new Map();
+  let lastApprovedIndex = -1;
+  let currentStatus = "in_progress";
+  let userQuery = "";
+  for (let i = 0; i < config.steps.length; i++) {
+    const stepName = config.steps[i];
+    const doc = loadDocument(taskId, stepName, cwd);
+    if (doc) {
+      outputs.set(stepName, {
+        path: getOutputPath(taskId, stepName, cwd),
+        status: doc.frontmatter.status
+      });
+      if (doc.frontmatter.status === "approved") {
+        lastApprovedIndex = i;
+      } else if (doc.frontmatter.status === "rejected") {
+        currentStatus = "rejected";
+      }
+      if (i === 0 && !userQuery) {
+        const queryMatch = doc.content.match(/## User Query\n\n(.+?)(?=\n\n|$)/s);
+        if (queryMatch) {
+          userQuery = queryMatch[1].trim();
+        }
+      }
+    }
+  }
+  if (lastApprovedIndex === config.steps.length - 1) {
+    currentStatus = "completed";
+  }
+  const currentStepIndex = Math.min(lastApprovedIndex + 1, config.steps.length - 1);
+  const currentStepName = config.steps[currentStepIndex];
+  const currentDoc = loadDocument(taskId, currentStepName, cwd);
+  if (currentDoc?.frontmatter.status === "draft" && currentDoc.frontmatter.open_questions?.length) {
+    currentStatus = "paused";
+  }
+  return {
+    taskId,
+    userQuery,
+    currentStepIndex,
+    currentStepName,
+    status: currentStatus,
+    outputs
+  };
+}
+function loadTaskMetadata(taskId, cwd = process.cwd()) {
+  const metaPath = join(getTaskDir(taskId, cwd), ".meta.json");
+  if (!existsSync(metaPath)) {
+    return null;
+  }
+  return JSON.parse(readFileSync(metaPath, "utf-8"));
+}
+
+// src/dashboard/client.ts
+var DashboardClient = class {
+  cwd;
+  config = null;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * Check if spets is initialized in the working directory
+   */
+  isInitialized() {
+    return spetsExists(this.cwd);
+  }
+  /**
+   * Get config, loading if necessary
+   */
+  getConfig() {
+    if (!this.config) {
+      this.config = loadConfig(this.cwd);
+    }
+    return this.config;
+  }
+  /**
+   * List all tasks with summary data
+   */
+  listTasks(options = {}) {
+    const limit = options.limit ?? 20;
+    const allTaskIds = listTasks(this.cwd);
+    const config = this.getConfig();
+    const tasks = [];
+    const taskIds = allTaskIds.slice(0, limit);
+    for (const taskId of taskIds) {
+      const summary = this.getTaskSummary(taskId, config);
+      if (summary) {
+        tasks.push(summary);
+      }
+    }
+    const metadata = {
+      totalTasks: allTaskIds.length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      truncated: allTaskIds.length > limit,
+      limit
+    };
+    return { tasks, metadata };
+  }
+  /**
+   * Get detailed data for a single task
+   */
+  getTaskDetail(taskId) {
+    const config = this.getConfig();
+    const state = getWorkflowState(taskId, config, this.cwd);
+    const meta = loadTaskMetadata(taskId, this.cwd);
+    if (!state) {
+      return null;
+    }
+    const query = meta?.userQuery || state.userQuery || "(no query)";
+    const status = this.mapWorkflowStatus(state.status);
+    const progress = this.buildProgress(state, config);
+    const steps = config.steps.map((stepName, index) => {
+      const output = state.outputs.get(stepName);
+      const isCurrent = index === state.currentStepIndex;
+      let stepStatus = "pending";
+      if (output) {
+        stepStatus = output.status;
+      }
+      return {
+        name: stepName,
+        index: index + 1,
+        status: stepStatus,
+        isCurrent,
+        outputPath: output ? getOutputPath(taskId, stepName, this.cwd) : void 0
+      };
+    });
+    const task = {
+      taskId,
+      query,
+      status,
+      progress,
+      createdAt: meta?.createdAt || "",
+      steps
+    };
+    return {
+      task,
+      metadata: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * Build summary for a single task
+   */
+  getTaskSummary(taskId, config) {
+    const state = getWorkflowState(taskId, config, this.cwd);
+    const meta = loadTaskMetadata(taskId, this.cwd);
+    if (!state) {
+      return null;
+    }
+    const query = meta?.userQuery || state.userQuery || "(no query)";
+    const status = this.mapWorkflowStatus(state.status);
+    const progress = this.buildProgress(state, config);
+    return {
+      taskId,
+      query,
+      status,
+      progress,
+      createdAt: meta?.createdAt || ""
+    };
+  }
+  /**
+   * Build progress object from workflow state
+   */
+  buildProgress(state, config) {
+    const totalSteps = config.steps.length;
+    const currentStepIndex = state.currentStepIndex + 1;
+    const completionPercent = Math.round(state.currentStepIndex / totalSteps * 100);
+    return {
+      currentStep: state.currentStepName,
+      currentStepIndex,
+      totalSteps,
+      completionPercent
+    };
+  }
+  /**
+   * Map internal workflow status to dashboard status
+   */
+  mapWorkflowStatus(status) {
+    switch (status) {
+      case "completed":
+        return "completed";
+      case "rejected":
+        return "rejected";
+      case "paused":
+        return "paused";
+      default:
+        return "in_progress";
+    }
+  }
+  /**
+   * Export dashboard data as JSON string
+   */
+  toJSON(options = {}) {
+    const response = this.listTasks(options);
+    return JSON.stringify(response, null, 2);
+  }
+  /**
+   * Export task detail as JSON string
+   */
+  taskToJSON(taskId) {
+    const response = this.getTaskDetail(taskId);
+    if (!response) return null;
+    return JSON.stringify(response, null, 2);
+  }
+};
+
+// src/dashboard/renderers/cli.ts
+import { select } from "@inquirer/prompts";
+var STATUS_ICONS = {
+  in_progress: "\u{1F504}",
+  completed: "\u2705",
+  paused: "\u23F8\uFE0F",
+  rejected: "\u274C"
+};
+var STEP_ICONS = {
+  pending: "\u25CB",
+  draft: "\u25D0",
+  approved: "\u25CF",
+  rejected: "\u2717"
+};
+var CLIDashboardRenderer = class {
+  /**
+   * Render task list in terminal format
+   */
+  renderList(response) {
+    const { tasks, metadata } = response;
+    const lines = [];
+    if (tasks.length === 0) {
+      lines.push("No tasks found.");
+      lines.push("");
+      lines.push('Start a new task with: spets start "your task description"');
+      return lines.join("\n");
+    }
+    lines.push("Tasks:");
+    lines.push("");
+    for (const task of tasks) {
+      const icon = STATUS_ICONS[task.status] || "\u2753";
+      const progress = `[${task.progress.currentStepIndex}/${task.progress.totalSteps}]`;
+      const truncatedQuery = task.query.length > 50 ? task.query.substring(0, 47) + "..." : task.query;
+      lines.push(`  ${task.taskId}  ${icon} ${task.status}  ${progress}`);
+      lines.push(`    ${truncatedQuery}`);
+      lines.push("");
+    }
+    if (metadata.truncated) {
+      lines.push(`  ... and ${metadata.totalTasks - metadata.limit} more tasks`);
+      lines.push("");
+    }
+    lines.push('Use "spets dashboard -t <taskId>" for details');
+    return lines.join("\n");
+  }
+  /**
+   * Render task detail in terminal format
+   */
+  renderDetail(response) {
+    const { task } = response;
+    const lines = [];
+    const icon = STATUS_ICONS[task.status] || "\u2753";
+    lines.push(`Task: ${task.taskId}`);
+    lines.push(`Query: ${task.query}`);
+    lines.push(`Status: ${icon} ${task.status}`);
+    lines.push(`Progress: ${task.progress.currentStepIndex}/${task.progress.totalSteps} (${task.progress.completionPercent}%)`);
+    lines.push("");
+    lines.push("Steps:");
+    for (const step of task.steps) {
+      const marker = step.isCurrent ? "\u2192" : " ";
+      const stepIcon = STEP_ICONS[step.status] || "\u25CB";
+      lines.push(`  ${marker} ${step.index}. ${step.name} ${stepIcon}`);
+    }
+    if (task.decisionHistory && task.decisionHistory.length > 0) {
+      lines.push("");
+      lines.push("Decision History:");
+      for (const entry of task.decisionHistory) {
+        lines.push(`  \u2022 ${entry.decision.decision}: ${entry.answer.selectedOptionId}`);
+      }
+    }
+    if (task.verifyOutput) {
+      lines.push("");
+      lines.push("Verification Scores:");
+      const scores = task.verifyOutput.score;
+      lines.push(`  Requirements: ${scores.requirementsCoverage}%`);
+      lines.push(`  Template: ${scores.templateCompliance}%`);
+      lines.push(`  Consistency: ${scores.consistency}%`);
+      lines.push(`  Completeness: ${scores.completeness}%`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Run interactive dashboard with drill-down navigation
+   */
+  async renderInteractive(client) {
+    while (true) {
+      const response = client.listTasks({ limit: 10 });
+      const { tasks } = response;
+      if (tasks.length === 0) {
+        console.log("\nNo tasks found.");
+        console.log('Start a new task with: spets start "your task description"');
+        break;
+      }
+      const choices = tasks.map((task) => {
+        const icon = STATUS_ICONS[task.status] || "\u2753";
+        const progress = `[${task.progress.currentStepIndex}/${task.progress.totalSteps}]`;
+        const truncatedQuery = task.query.length > 40 ? task.query.substring(0, 37) + "..." : task.query;
+        return {
+          value: task.taskId,
+          name: `${icon} ${task.taskId} ${progress} - ${truncatedQuery}`
+        };
+      });
+      choices.push({ value: "_exit_", name: "\u2190 Exit dashboard" });
+      const selected = await select({
+        message: "Select a task to view details:",
+        choices
+      });
+      if (selected === "_exit_") {
+        break;
+      }
+      const detail = client.getTaskDetail(selected);
+      if (detail) {
+        console.log("\n" + "=".repeat(60));
+        console.log(this.renderDetail(detail));
+        console.log("=".repeat(60));
+        const action = await select({
+          message: "What would you like to do?",
+          choices: [
+            { value: "back", name: "\u2190 Back to task list" },
+            { value: "resume", name: "\u25B6 Resume this task" },
+            { value: "exit", name: "\u2715 Exit dashboard" }
+          ]
+        });
+        if (action === "exit") {
+          break;
+        }
+        if (action === "resume") {
+          console.log(`
+To resume this task, run:`);
+          console.log(`  spets resume -t ${selected}`);
+          break;
+        }
+      }
+    }
+  }
+};
+
+// src/dashboard/renderers/json.ts
+var JSONDashboardRenderer = class {
+  prettyPrint;
+  constructor(options = {}) {
+    this.prettyPrint = options.prettyPrint ?? true;
+  }
+  /**
+   * Render dashboard response as JSON string
+   */
+  render(response) {
+    return this.stringify(response);
+  }
+  /**
+   * Render task detail as JSON string
+   */
+  renderDetail(response) {
+    return this.stringify(response);
+  }
+  /**
+   * Render any data as JSON string
+   */
+  stringify(data) {
+    if (this.prettyPrint) {
+      return JSON.stringify(data, null, 2);
+    }
+    return JSON.stringify(data);
+  }
+};
+
+// src/ui/sections/tasks.ts
+function renderTasksJSON(taskId, cwd = process.cwd()) {
+  const client = new DashboardClient(cwd);
+  const renderer = new JSONDashboardRenderer();
+  if (taskId) {
+    const detail = client.getTaskDetail(taskId);
+    if (!detail) {
+      return JSON.stringify({ error: `Task '${taskId}' not found` });
+    }
+    return renderer.renderDetail(detail);
+  }
+  const response = client.listTasks({ limit: 50 });
+  return renderer.render(response);
+}
+async function runTasksInteractive(cwd = process.cwd()) {
+  const client = new DashboardClient(cwd);
+  const renderer = new CLIDashboardRenderer();
+  while (true) {
+    const response = client.listTasks({ limit: 20 });
+    const { tasks } = response;
+    if (tasks.length === 0) {
+      console.log("\nNo tasks found.");
+      console.log('Start a new task with: spets start "your task description"');
+      break;
+    }
+    const STATUS_ICONS2 = {
+      in_progress: "\u{1F504}",
+      completed: "\u2705",
+      paused: "\u23F8\uFE0F",
+      rejected: "\u274C"
+    };
+    const choices = tasks.map((task) => {
+      const icon = STATUS_ICONS2[task.status] || "\u2753";
+      const progress = `[${task.progress.currentStepIndex}/${task.progress.totalSteps}]`;
+      const truncatedQuery = task.query.length > 40 ? task.query.substring(0, 37) + "..." : task.query;
+      return {
+        value: task.taskId,
+        name: `${icon} ${task.taskId} ${progress} - ${truncatedQuery}`
+      };
+    });
+    choices.push({ value: "_back_", name: "\u2190 Back to main menu" });
+    const selected = await select2({
+      message: "Select a task to view details:",
+      choices
+    });
+    if (selected === "_back_") {
+      break;
+    }
+    const detail = client.getTaskDetail(selected);
+    if (detail) {
+      console.log("\n" + "=".repeat(60));
+      console.log(renderer.renderDetail(detail));
+      console.log("=".repeat(60));
+      const action = await select2({
+        message: "What would you like to do?",
+        choices: [
+          { value: "back", name: "\u2190 Back to task list" },
+          { value: "resume", name: "\u25B6 Resume this task" },
+          { value: "exit", name: "\u2715 Exit to main menu" }
+        ]
+      });
+      if (action === "exit") {
+        break;
+      }
+      if (action === "resume") {
+        console.log(`
+To resume this task, run:`);
+        console.log(`  spets resume -t ${selected}`);
+        break;
+      }
+    }
+  }
+}
+
+export {
+  generateTaskId,
+  listTasks,
+  getWorkflowState,
+  loadTaskMetadata,
+  DashboardClient,
+  JSONDashboardRenderer,
+  CLIDashboardRenderer,
+  renderTasksJSON,
+  runTasksInteractive
+};