clawvault 2.2.0 → 2.3.0

package/dist/commands/backlog.js

@@ -0,0 +1,119 @@
+import {
+  createBacklogItem,
+  listBacklogItems,
+  promoteBacklogItem
+} from "../chunk-NGVAEFT2.js";
+
+// src/commands/backlog.ts
+function backlogAdd(vaultPath, title, options = {}) {
+  return createBacklogItem(vaultPath, title, {
+    source: options.source,
+    project: options.project,
+    content: options.content,
+    tags: options.tags
+  });
+}
+function backlogList(vaultPath, options = {}) {
+  const filters = {};
+  if (options.project) filters.project = options.project;
+  return listBacklogItems(vaultPath, filters);
+}
+function backlogPromote(vaultPath, slug, options = {}) {
+  return promoteBacklogItem(vaultPath, slug, {
+    owner: options.owner,
+    priority: options.priority,
+    due: options.due
+  });
+}
+function formatBacklogList(items) {
+  if (items.length === 0) {
+    return "No backlog items found.\n";
+  }
+  const headers = ["SOURCE", "PROJECT", "CREATED", "TITLE"];
+  const widths = [12, 16, 12, 40];
+  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
+  for (const item of items) {
+    const source = item.frontmatter.source || "-";
+    const project = item.frontmatter.project || "-";
+    const created = item.frontmatter.created.split("T")[0];
+    const title = item.title.length > widths[3] ? item.title.slice(0, widths[3] - 3) + "..." : item.title;
+    const row = [
+      source.padEnd(widths[0]),
+      project.padEnd(widths[1]),
+      created.padEnd(widths[2]),
+      title
+    ];
+    output += row.join("  ") + "\n";
+  }
+  return output;
+}
+function formatBacklogDetails(item) {
+  let output = "";
+  output += `# ${item.title}
+`;
+  output += "-".repeat(40) + "\n";
+  if (item.frontmatter.source) {
+    output += `Source: ${item.frontmatter.source}
+`;
+  }
+  if (item.frontmatter.project) {
+    output += `Project: ${item.frontmatter.project}
+`;
+  }
+  if (item.frontmatter.tags && item.frontmatter.tags.length > 0) {
+    output += `Tags: ${item.frontmatter.tags.join(", ")}
+`;
+  }
+  output += `Created: ${item.frontmatter.created}
+`;
+  output += `File: ${item.path}
+`;
+  output += "-".repeat(40) + "\n";
+  const contentWithoutTitle = item.content.replace(/^#\s+.+\n/, "").trim();
+  if (contentWithoutTitle) {
+    output += "\n" + contentWithoutTitle + "\n";
+  }
+  return output;
+}
+async function backlogCommand(vaultPath, action, args) {
+  const options = args.options || {};
+  switch (action) {
+    case "add": {
+      if (!args.title) {
+        throw new Error("Title is required for backlog add");
+      }
+      const item = backlogAdd(vaultPath, args.title, options);
+      console.log(`\u2713 Added to backlog: ${item.slug}`);
+      console.log(`  Path: ${item.path}`);
+      break;
+    }
+    case "list": {
+      const items = backlogList(vaultPath, options);
+      if (options.json) {
+        console.log(JSON.stringify(items, null, 2));
+      } else {
+        console.log(formatBacklogList(items));
+      }
+      break;
+    }
+    case "promote": {
+      if (!args.slug) {
+        throw new Error("Backlog item slug is required for promote");
+      }
+      const task = backlogPromote(vaultPath, args.slug, options);
+      console.log(`\u2713 Promoted to task: ${task.slug}`);
+      console.log(`  Path: ${task.path}`);
+      break;
+    }
+    default:
+      throw new Error(`Unknown backlog action: ${action}`);
+  }
+}
+export {
+  backlogAdd,
+  backlogCommand,
+  backlogList,
+  backlogPromote,
+  formatBacklogDetails,
+  formatBacklogList
+};

package/dist/commands/blocked.d.ts

@@ -0,0 +1,25 @@
+import { Task } from '../lib/task-utils.js';
+
+/**
+ * Blocked command for ClawVault
+ * Quick view of blocked tasks
+ */
+
+interface BlockedOptions {
+    project?: string;
+    json?: boolean;
+}
+/**
+ * Get blocked tasks
+ */
+declare function blockedList(vaultPath: string, options?: BlockedOptions): Task[];
+/**
+ * Format blocked tasks for terminal display
+ */
+declare function formatBlockedList(tasks: Task[]): string;
+/**
+ * Blocked command handler for CLI
+ */
+declare function blockedCommand(vaultPath: string, options?: BlockedOptions): Promise<void>;
+
+export { type BlockedOptions, blockedCommand, blockedList, formatBlockedList };

package/dist/commands/blocked.js

@@ -0,0 +1,43 @@
+import {
+  getBlockedTasks
+} from "../chunk-NGVAEFT2.js";
+
+// src/commands/blocked.ts
+function blockedList(vaultPath, options = {}) {
+  return getBlockedTasks(vaultPath, options.project);
+}
+function formatBlockedList(tasks) {
+  if (tasks.length === 0) {
+    return "No blocked tasks.\n";
+  }
+  let output = `BLOCKED TASKS (${tasks.length})
+
+`;
+  for (const task of tasks) {
+    const owner = task.frontmatter.owner || "unassigned";
+    const project = task.frontmatter.project || "no project";
+    const blockedBy = task.frontmatter.blocked_by || "unknown";
+    const updatedDate = task.frontmatter.updated.split("T")[0];
+    output += `\u25A0 ${task.title} (${owner}, ${project})
+`;
+    output += `  Blocked by: ${blockedBy}
+`;
+    output += `  Since: ${updatedDate}
+`;
+    output += "\n";
+  }
+  return output;
+}
+async function blockedCommand(vaultPath, options = {}) {
+  const tasks = blockedList(vaultPath, options);
+  if (options.json) {
+    console.log(JSON.stringify(tasks, null, 2));
+  } else {
+    console.log(formatBlockedList(tasks));
+  }
+}
+export {
+  blockedCommand,
+  blockedList,
+  formatBlockedList
+};

package/dist/commands/canvas.d.ts

@@ -0,0 +1,20 @@
+import { Canvas } from '../lib/canvas-layout.js';
+
+/**
+ * Canvas command for ClawVault
+ * Generates an Obsidian JSON Canvas dashboard
+ */
+
+interface CanvasOptions {
+    output?: string;
+}
+/**
+ * Generate the canvas dashboard
+ */
+declare function generateCanvas(vaultPath: string): Canvas;
+/**
+ * Canvas command handler for CLI
+ */
+declare function canvasCommand(vaultPath: string, options?: CanvasOptions): Promise<void>;
+
+export { type CanvasOptions, canvasCommand, generateCanvas };

package/dist/commands/canvas.js

@@ -0,0 +1,309 @@
+import {
+  CANVAS_COLORS,
+  LAYOUT,
+  createEdge,
+  createFileNode,
+  createGroupNode,
+  createGroupWithNodes,
+  createTextNode,
+  flattenGroups,
+  getPriorityColor,
+  positionGroupsVertically,
+  truncateText
+} from "../chunk-MDIH26GC.js";
+import {
+  getActiveTasks,
+  getBlockedTasks,
+  getRecentlyCompletedTasks,
+  listBacklogItems,
+  listTasks
+} from "../chunk-NGVAEFT2.js";
+import {
+  loadMemoryGraphIndex
+} from "../chunk-ZZA73MFY.js";
+import {
+  getReflectionsRoot,
+  listObservationFiles
+} from "../chunk-Z2XBWN7A.js";
+
+// src/commands/canvas.ts
+import * as fs from "fs";
+import * as path from "path";
+function generateCanvas(vaultPath) {
+  const resolvedPath = path.resolve(vaultPath);
+  const nodes = [];
+  const edges = [];
+  const activeTasks = getActiveTasks(resolvedPath);
+  const blockedTasks = getBlockedTasks(resolvedPath);
+  const backlogItems = listBacklogItems(resolvedPath);
+  const recentlyDone = getRecentlyCompletedTasks(resolvedPath, 10);
+  const graphIndex = loadMemoryGraphIndex(resolvedPath);
+  const leftGroups = [];
+  const knowledgeGraphGroup = buildKnowledgeGraphGroup(resolvedPath, graphIndex?.graph);
+  leftGroups.push(knowledgeGraphGroup);
+  const vaultStatsGroup = buildVaultStatsGroup(resolvedPath, graphIndex?.graph);
+  leftGroups.push(vaultStatsGroup);
+  const rightGroups = [];
+  if (activeTasks.length > 0) {
+    const activeTasksGroup = buildActiveTasksGroup(activeTasks);
+    rightGroups.push(activeTasksGroup);
+  }
+  if (blockedTasks.length > 0) {
+    const blockedTasksGroup = buildBlockedTasksGroup(blockedTasks);
+    rightGroups.push(blockedTasksGroup);
+  }
+  if (backlogItems.length > 0) {
+    const backlogGroup = buildBacklogGroup(backlogItems);
+    rightGroups.push(backlogGroup);
+  }
+  if (recentlyDone.length > 0) {
+    const recentlyDoneGroup = buildRecentlyDoneGroup(recentlyDone);
+    rightGroups.push(recentlyDoneGroup);
+  }
+  const positionedLeft = positionGroupsVertically(leftGroups, 0);
+  const positionedRight = positionGroupsVertically(rightGroups, 0);
+  nodes.push(...flattenGroups(positionedLeft));
+  nodes.push(...flattenGroups(positionedRight));
+  const maxLeftHeight = positionedLeft.length > 0 ? positionedLeft[positionedLeft.length - 1].group.y + positionedLeft[positionedLeft.length - 1].group.height : 0;
+  const maxRightHeight = positionedRight.length > 0 ? positionedRight[positionedRight.length - 1].group.y + positionedRight[positionedRight.length - 1].group.height : 0;
+  const bottomY = Math.max(maxLeftHeight, maxRightHeight) + LAYOUT.GROUP_SPACING;
+  const dataFlowResult = buildDataFlowDiagram(bottomY);
+  nodes.push(...dataFlowResult.nodes);
+  edges.push(...dataFlowResult.edges);
+  const taskSlugs = new Set(listTasks(resolvedPath).map((t) => t.slug));
+  for (const task of blockedTasks) {
+    if (task.frontmatter.blocked_by) {
+      const blockerSlug = task.frontmatter.blocked_by.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-");
+      if (taskSlugs.has(blockerSlug)) {
+        const taskNode = nodes.find((n) => n.type === "file" && n.file === `tasks/${task.slug}.md`);
+        const blockerNode = nodes.find((n) => n.type === "file" && n.file === `tasks/${blockerSlug}.md`);
+        if (taskNode && blockerNode) {
+          edges.push(createEdge(taskNode.id, "left", blockerNode.id, "right", "blocked by", CANVAS_COLORS.RED));
+        }
+      }
+    }
+  }
+  return { nodes, edges };
+}
+function buildKnowledgeGraphGroup(vaultPath, graph) {
+  const childNodes = [];
+  let statsText = "**Knowledge Graph**\n\n";
+  if (graph) {
+    statsText += `Nodes: ${graph.stats.nodeCount}
+`;
+    statsText += `Edges: ${graph.stats.edgeCount}
+`;
+    statsText += `Files: ${Object.keys(graph.stats.nodeTypeCounts).filter((t) => t !== "tag" && t !== "unresolved").reduce((sum, t) => sum + (graph.stats.nodeTypeCounts[t] || 0), 0)}
+`;
+  } else {
+    statsText += "Graph not available\n";
+  }
+  childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT, statsText));
+  if (graph && graph.nodes.length > 0) {
+    const topEntities = graph.nodes.filter((n) => n.type !== "tag" && n.type !== "unresolved").sort((a, b) => b.degree - a.degree).slice(0, 10);
+    if (topEntities.length > 0) {
+      const entitiesText = "**Top Entities**\n\n" + topEntities.map((e) => `- ${e.title} (${e.degree})`).join("\n");
+      childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT + 40, entitiesText));
+    }
+  }
+  const decisionsDir = path.join(vaultPath, "decisions");
+  if (fs.existsSync(decisionsDir)) {
+    const decisionFiles = fs.readdirSync(decisionsDir).filter((f) => f.endsWith(".md")).slice(0, 5);
+    if (decisionFiles.length > 0) {
+      const decisionsText = "**Recent Decisions**\n\n" + decisionFiles.map((f) => `- ${f.replace(".md", "")}`).join("\n");
+      childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT, decisionsText));
+    }
+  }
+  return createGroupWithNodes(
+    LAYOUT.LEFT_COLUMN_X,
+    0,
+    LAYOUT.LEFT_COLUMN_WIDTH,
+    "\u{1F9E0} Knowledge Graph",
+    childNodes,
+    CANVAS_COLORS.PURPLE
+  );
+}
+function buildVaultStatsGroup(vaultPath, graph) {
+  const childNodes = [];
+  let categoryText = "**Categories**\n\n";
+  if (graph) {
+    const typeCounts = graph.stats.nodeTypeCounts;
+    const categories = Object.entries(typeCounts).filter(([type]) => type !== "tag" && type !== "unresolved").sort((a, b) => b[1] - a[1]);
+    for (const [type, count] of categories) {
+      categoryText += `- ${type}: ${count}
+`;
+    }
+  } else {
+    categoryText += "Stats not available\n";
+  }
+  childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT + 20, categoryText));
+  const observationFiles = listObservationFiles(vaultPath, { includeLegacy: true, includeArchive: false });
+  const recentObsCount = observationFiles.length;
+  let obsText = "**Observations**\n\n";
+  obsText += `Total days: ${recentObsCount}
+`;
+  if (recentObsCount > 0) {
+    const latestDate = observationFiles[observationFiles.length - 1]?.date || "N/A";
+    obsText += `Latest: ${latestDate}
+`;
+  }
+  childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.SMALL_NODE_HEIGHT + 20, obsText));
+  const reflectionsRoot = getReflectionsRoot(vaultPath);
+  if (fs.existsSync(reflectionsRoot)) {
+    const reflectionFiles = fs.readdirSync(reflectionsRoot, { recursive: true }).filter((f) => typeof f === "string" && f.endsWith(".md")).sort().reverse();
+    if (reflectionFiles.length > 0) {
+      const latestReflection = reflectionFiles[0];
+      const reflectionPath = path.join(reflectionsRoot, latestReflection);
+      try {
+        const content = fs.readFileSync(reflectionPath, "utf-8");
+        const openLoopsMatch = content.match(/## Open Loops\n([\s\S]*?)(?=\n##|$)/);
+        if (openLoopsMatch) {
+          const openLoops = openLoopsMatch[1].trim().split("\n").filter((l) => l.startsWith("-")).slice(0, 5);
+          if (openLoops.length > 0) {
+            const loopsText = "**Open Loops**\n\n" + openLoops.join("\n");
+            childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT, loopsText));
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return createGroupWithNodes(
+    LAYOUT.LEFT_COLUMN_X,
+    0,
+    LAYOUT.LEFT_COLUMN_WIDTH,
+    "\u{1F4CA} Vault Stats",
+    childNodes,
+    CANVAS_COLORS.CYAN
+  );
+}
+function buildActiveTasksGroup(tasks) {
+  const childNodes = [];
+  for (const task of tasks.slice(0, 10)) {
+    const color = getPriorityColor(task.frontmatter.priority);
+    const relativePath = `tasks/${task.slug}.md`;
+    childNodes.push(createFileNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.FILE_NODE_HEIGHT, relativePath, color));
+  }
+  if (tasks.length > 10) {
+    childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.SMALL_NODE_HEIGHT, `... and ${tasks.length - 10} more`));
+  }
+  return createGroupWithNodes(
+    LAYOUT.RIGHT_COLUMN_X,
+    0,
+    LAYOUT.RIGHT_COLUMN_WIDTH,
+    "\u25CF Active Tasks",
+    childNodes
+  );
+}
+function buildBlockedTasksGroup(tasks) {
+  const childNodes = [];
+  for (const task of tasks.slice(0, 10)) {
+    const blockerInfo = task.frontmatter.blocked_by || "unknown";
+    const since = task.frontmatter.updated.split("T")[0];
+    const text = `**${truncateText(task.title, 30)}**
+Blocked by: ${blockerInfo}
+Since: ${since}`;
+    childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT, text, CANVAS_COLORS.RED));
+  }
+  return createGroupWithNodes(
+    LAYOUT.RIGHT_COLUMN_X,
+    0,
+    LAYOUT.RIGHT_COLUMN_WIDTH,
+    "\u25A0 Blocked",
+    childNodes,
+    CANVAS_COLORS.RED
+  );
+}
+function buildBacklogGroup(items) {
+  const childNodes = [];
+  if (items.length > 5) {
+    const byProject = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const project = item.frontmatter.project || "No Project";
+      const existing = byProject.get(project) || [];
+      existing.push(item);
+      byProject.set(project, existing);
+    }
+    for (const [project, projectItems] of byProject) {
+      const itemsList = projectItems.slice(0, 5).map((i) => `- ${truncateText(i.title, 35)}`).join("\n");
+      const moreText = projectItems.length > 5 ? `
+... +${projectItems.length - 5} more` : "";
+      const text = `**${project}**
+
+${itemsList}${moreText}`;
+      childNodes.push(createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT + 20, text));
+    }
+  } else {
+    for (const item of items) {
+      const relativePath = `backlog/${item.slug}.md`;
+      childNodes.push(createFileNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.FILE_NODE_HEIGHT, relativePath));
+    }
+  }
+  return createGroupWithNodes(
+    LAYOUT.RIGHT_COLUMN_X,
+    0,
+    LAYOUT.RIGHT_COLUMN_WIDTH,
+    "\u{1F4CB} Backlog",
+    childNodes
+  );
+}
+function buildRecentlyDoneGroup(tasks) {
+  const childNodes = [];
+  for (const task of tasks.slice(0, 10)) {
+    const relativePath = `tasks/${task.slug}.md`;
+    childNodes.push(createFileNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.FILE_NODE_HEIGHT, relativePath, CANVAS_COLORS.GREEN));
+  }
+  return createGroupWithNodes(
+    LAYOUT.RIGHT_COLUMN_X,
+    0,
+    LAYOUT.RIGHT_COLUMN_WIDTH,
+    "\u2713 Recently Done",
+    childNodes,
+    CANVAS_COLORS.GREEN
+  );
+}
+function buildDataFlowDiagram(startY) {
+  const nodes = [];
+  const edges = [];
+  const flowSteps = ["Session", "Observe", "Score", "Route", "Reflect", "Promote"];
+  const nodeWidth = 100;
+  const nodeHeight = 40;
+  const spacing = 30;
+  const totalWidth = flowSteps.length * nodeWidth + (flowSteps.length - 1) * spacing;
+  const startX = LAYOUT.LEFT_COLUMN_X + (LAYOUT.LEFT_COLUMN_WIDTH + LAYOUT.RIGHT_COLUMN_WIDTH + 50 - totalWidth) / 2;
+  const groupWidth = totalWidth + LAYOUT.GROUP_PADDING * 2;
+  const groupHeight = nodeHeight + LAYOUT.GROUP_HEADER_HEIGHT + LAYOUT.GROUP_PADDING * 2;
+  const group = createGroupNode(startX - LAYOUT.GROUP_PADDING, startY, groupWidth, groupHeight, "Data Flow", CANVAS_COLORS.CYAN);
+  nodes.push(group);
+  const stepNodes = [];
+  let currentX = startX;
+  for (const step of flowSteps) {
+    const node = createTextNode(
+      currentX,
+      startY + LAYOUT.GROUP_HEADER_HEIGHT + LAYOUT.GROUP_PADDING,
+      nodeWidth,
+      nodeHeight,
+      `**${step}**`
+    );
+    stepNodes.push(node);
+    nodes.push(node);
+    currentX += nodeWidth + spacing;
+  }
+  for (let i = 0; i < stepNodes.length - 1; i++) {
+    edges.push(createEdge(stepNodes[i].id, "right", stepNodes[i + 1].id, "left", "\u2192"));
+  }
+  return { nodes, edges };
+}
+async function canvasCommand(vaultPath, options = {}) {
+  const resolvedPath = path.resolve(vaultPath);
+  const outputPath = options.output || path.join(resolvedPath, "dashboard.canvas");
+  const canvas = generateCanvas(resolvedPath);
+  fs.writeFileSync(outputPath, JSON.stringify(canvas, null, 2));
+  console.log(`\u2713 Generated canvas dashboard: ${outputPath}`);
+  console.log(`  Nodes: ${canvas.nodes.length}`);
+  console.log(`  Edges: ${canvas.edges.length}`);
+}
+export {
+  canvasCommand,
+  generateCanvas
+};

package/dist/commands/context.js

@@ -3,12 +3,12 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "../chunk-6RIHODNR.js";
+} from "../chunk-SOTWYGH7.js";
+import "../chunk-OTQW3OMC.js";
+import "../chunk-FDJIZKCW.js";
 import "../chunk-K6XHCUFL.js";
-import "../chunk-Z2XBWN7A.js";
-import "../chunk-IFGDPIFI.js";
-import "../chunk-DHBDH4DN.js";
 import "../chunk-ZZA73MFY.js";
+import "../chunk-Z2XBWN7A.js";
 export {
   buildContext,
   contextCommand,

package/dist/commands/doctor.js

@@ -1,6 +1,7 @@
 import {
   scanVaultLinks
 } from "../chunk-4VQTUVH7.js";
+import "../chunk-J7ZWCI2C.js";
 import {
   formatAge
 } from "../chunk-7ZRP733D.js";
@@ -10,11 +11,10 @@ import {
 import {
   ClawVault,
   findVault
-} from "../chunk-IFGDPIFI.js";
+} from "../chunk-OTQW3OMC.js";
 import {
   hasQmd
-} from "../chunk-DHBDH4DN.js";
-import "../chunk-J7ZWCI2C.js";
+} from "../chunk-FDJIZKCW.js";
 import {
   loadMemoryGraphIndex
 } from "../chunk-ZZA73MFY.js";

package/dist/commands/graph.js

@@ -1,9 +1,9 @@
 import {
   graphCommand,
   graphSummary
-} from "../chunk-H7JW4L7H.js";
-import "../chunk-ZZA73MFY.js";
+} from "../chunk-OZ7RIXTO.js";
 import "../chunk-MXSSG3QU.js";
+import "../chunk-ZZA73MFY.js";
 export {
   graphCommand,
   graphSummary

package/dist/commands/link.js

@@ -11,12 +11,12 @@ import {
 import {
   buildEntityIndex
 } from "../chunk-J7ZWCI2C.js";
-import {
-  buildOrUpdateMemoryGraphIndex
-} from "../chunk-ZZA73MFY.js";
 import {
   resolveVaultPath
 } from "../chunk-MXSSG3QU.js";
+import {
+  buildOrUpdateMemoryGraphIndex
+} from "../chunk-ZZA73MFY.js";
 
 // src/commands/link.ts
 import * as fs from "fs";

package/dist/commands/migrate-observations.js

@@ -2,10 +2,10 @@ import {
   migrateObservations,
   migrateObservationsCommand,
   registerMigrateObservationsCommand
-} from "../chunk-WZI3OAE5.js";
+} from "../chunk-5WR6RRPX.js";
+import "../chunk-MXSSG3QU.js";
 import "../chunk-K6XHCUFL.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-MXSSG3QU.js";
 export {
   migrateObservations,
   migrateObservationsCommand,

package/dist/commands/observe.js

@@ -1,13 +1,13 @@
 import {
   observeCommand,
   registerObserveCommand
-} from "../chunk-LB6P4CD5.js";
-import "../chunk-P5EPF6MB.js";
+} from "../chunk-PTSEIWXZ.js";
 import "../chunk-HRLWZGMA.js";
+import "../chunk-P5EPF6MB.js";
 import "../chunk-2HM7ZI4X.js";
+import "../chunk-MXSSG3QU.js";
 import "../chunk-K6XHCUFL.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-MXSSG3QU.js";
 export {
   observeCommand,
   registerObserveCommand

package/dist/commands/rebuild.js

@@ -1,11 +1,11 @@
 import {
   rebuildCommand,
   registerRebuildCommand
-} from "../chunk-73P7XCQM.js";
+} from "../chunk-DPS7NYIU.js";
 import "../chunk-2HM7ZI4X.js";
+import "../chunk-MXSSG3QU.js";
 import "../chunk-K6XHCUFL.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-MXSSG3QU.js";
 export {
   rebuildCommand,
   registerRebuildCommand

package/dist/commands/recover.js

@@ -1,9 +1,9 @@
 import {
   formatRecoveryInfo,
   recover
-} from "../chunk-MILVYUPK.js";
-import "../chunk-MZZJLQNQ.js";
+} from "../chunk-IWYZAXKJ.js";
 import "../chunk-7ZRP733D.js";
+import "../chunk-MZZJLQNQ.js";
 export {
   formatRecoveryInfo,
   recover

package/dist/commands/reflect.js

@@ -4,9 +4,9 @@ import {
 } from "../chunk-GJEGPO7U.js";
 import "../chunk-GQVYQCY5.js";
 import "../chunk-MQUJNOHK.js";
+import "../chunk-MXSSG3QU.js";
 import "../chunk-K6XHCUFL.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-MXSSG3QU.js";
 export {
   reflectCommand,
   registerReflectCommand

package/dist/commands/replay.js

@@ -1,13 +1,13 @@
 import {
   registerReplayCommand,
   replayCommand
-} from "../chunk-L6NB43WV.js";
-import "../chunk-2HM7ZI4X.js";
+} from "../chunk-6BBTI7NV.js";
 import "../chunk-GQVYQCY5.js";
+import "../chunk-2HM7ZI4X.js";
 import "../chunk-MQUJNOHK.js";
+import "../chunk-MXSSG3QU.js";
 import "../chunk-K6XHCUFL.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-MXSSG3QU.js";
 export {
   registerReplayCommand,
   replayCommand

package/dist/commands/setup.js

@@ -1,7 +1,7 @@
 import {
   setupCommand
-} from "../chunk-KNDVXXKC.js";
-import "../chunk-DHBDH4DN.js";
+} from "../chunk-W463YRED.js";
+import "../chunk-FDJIZKCW.js";
 export {
   setupCommand
 };