clawvault 2.4.5 → 2.4.7

package/dist/commands/context.js

@@ -3,14 +3,13 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "../chunk-22WE3J4F.js";
-import "../chunk-HNMFXFYP.js";
+} from "../chunk-WIICLBNF.js";
+import "../chunk-7OHQFMJK.js";
 import "../chunk-6B3JWM7J.js";
-import "../chunk-3PJIGGWV.js";
-import "../chunk-L3DJ36BZ.js";
-import "../chunk-ZZA73MFY.js";
+import "../chunk-2CDEETQN.js";
 import "../chunk-FHFUXL6G.js";
-import "../chunk-NAMFB7ZA.js";
+import "../chunk-ZZA73MFY.js";
+import "../chunk-Z2XBWN7A.js";
 export {
   buildContext,
   contextCommand,

package/dist/commands/doctor.js

@@ -1,21 +1,21 @@
+import {
+  formatAge
+} from "../chunk-7ZRP733D.js";
 import {
   scanVaultLinks
 } from "../chunk-4VQTUVH7.js";
 import "../chunk-J7ZWCI2C.js";
-import {
-  formatAge
-} from "../chunk-7ZRP733D.js";
 import {
   checkOpenClawCompatibility
 } from "../chunk-PAYUH64O.js";
 import {
   ClawVault,
   findVault
-} from "../chunk-HNMFXFYP.js";
+} from "../chunk-7OHQFMJK.js";
 import {
   hasQmd
 } from "../chunk-6B3JWM7J.js";
-import "../chunk-3PJIGGWV.js";
+import "../chunk-2CDEETQN.js";
 import {
   loadMemoryGraphIndex
 } from "../chunk-ZZA73MFY.js";

package/dist/commands/inject.d.ts

@@ -0,0 +1,2 @@
+import 'commander';
+export { I as InjectCommandOptions, a as InjectFormat, q as buildInjectionResult, v as injectCommand, x as registerInjectCommand } from '../inject-x65KXWPk.js';

package/dist/commands/inject.js

@@ -0,0 +1,14 @@
+import {
+  buildInjectionResult,
+  injectCommand,
+  registerInjectCommand
+} from "../chunk-GSD4ALSI.js";
+import "../chunk-K3CDT7IH.js";
+import "../chunk-ITPEXLHA.js";
+import "../chunk-2CDEETQN.js";
+import "../chunk-ZZA73MFY.js";
+export {
+  buildInjectionResult,
+  injectCommand,
+  registerInjectCommand
+};

package/dist/commands/kanban.d.ts

@@ -0,0 +1,63 @@
+import { Task } from '../lib/task-utils.js';
+
+/**
+ * Kanban command for ClawVault.
+ * Syncs task frontmatter to/from Obsidian Kanban markdown boards.
+ */
+
+type KanbanGroupBy = 'status' | 'priority' | 'project' | 'owner';
+interface KanbanSyncOptions {
+    output?: string;
+    groupBy?: KanbanGroupBy | string;
+    filterProject?: string;
+    filterOwner?: string;
+    includeDone?: boolean;
+    now?: Date;
+}
+interface KanbanImportOptions {
+    output?: string;
+}
+interface KanbanLane {
+    name: string;
+    cards: string[];
+}
+interface KanbanSyncResult {
+    outputPath: string;
+    groupBy: KanbanGroupBy;
+    markdown: string;
+    lanes: KanbanLane[];
+    taskCount: number;
+}
+interface KanbanImportChange {
+    slug: string;
+    field: KanbanGroupBy;
+    from: string | null;
+    to: string | null;
+}
+interface KanbanImportResult {
+    outputPath: string;
+    groupBy: KanbanGroupBy;
+    changes: KanbanImportChange[];
+    missingSlugs: string[];
+}
+interface ParsedKanbanLane {
+    name: string;
+    slugs: string[];
+}
+interface ParsedKanbanBoard {
+    groupBy: KanbanGroupBy;
+    lanes: ParsedKanbanLane[];
+}
+declare function formatKanbanCard(task: Task): string;
+declare function buildKanbanLanes(tasks: Task[], groupBy: KanbanGroupBy): KanbanLane[];
+declare function generateKanbanMarkdown(tasks: Task[], options?: {
+    groupBy?: KanbanGroupBy | string;
+    now?: Date;
+}): string;
+declare function syncKanbanBoard(vaultPath: string, options?: KanbanSyncOptions): KanbanSyncResult;
+declare function extractCardSlug(line: string): string | null;
+declare function parseKanbanMarkdown(markdown: string): ParsedKanbanBoard;
+declare function importKanbanBoard(vaultPath: string, options?: KanbanImportOptions): KanbanImportResult;
+declare function kanbanCommand(vaultPath: string, action: 'sync' | 'import', options?: KanbanSyncOptions & KanbanImportOptions): Promise<void>;
+
+export { type KanbanGroupBy, type KanbanImportChange, type KanbanImportOptions, type KanbanImportResult, type KanbanLane, type KanbanSyncOptions, type KanbanSyncResult, type ParsedKanbanBoard, type ParsedKanbanLane, buildKanbanLanes, extractCardSlug, formatKanbanCard, generateKanbanMarkdown, importKanbanBoard, kanbanCommand, parseKanbanMarkdown, syncKanbanBoard };

package/dist/commands/kanban.js

@@ -0,0 +1,21 @@
+import {
+  buildKanbanLanes,
+  extractCardSlug,
+  formatKanbanCard,
+  generateKanbanMarkdown,
+  importKanbanBoard,
+  kanbanCommand,
+  parseKanbanMarkdown,
+  syncKanbanBoard
+} from "../chunk-J5EMBUPK.js";
+import "../chunk-IOALNTAN.js";
+export {
+  buildKanbanLanes,
+  extractCardSlug,
+  formatKanbanCard,
+  generateKanbanMarkdown,
+  importKanbanBoard,
+  kanbanCommand,
+  parseKanbanMarkdown,
+  syncKanbanBoard
+};

package/dist/commands/migrate-observations.js

@@ -2,10 +2,10 @@ import {
   migrateObservations,
   migrateObservationsCommand,
   registerMigrateObservationsCommand
-} from "../chunk-JXY6T5R7.js";
+} from "../chunk-FW465EEA.js";
 import "../chunk-MXSSG3QU.js";
 import "../chunk-FHFUXL6G.js";
-import "../chunk-NAMFB7ZA.js";
+import "../chunk-Z2XBWN7A.js";
 export {
   migrateObservations,
   migrateObservationsCommand,

package/dist/commands/observe.js

@@ -1,15 +1,17 @@
 import {
   observeCommand,
   registerObserveCommand
-} from "../chunk-B3SMJZIZ.js";
-import "../chunk-HRLWZGMA.js";
+} from "../chunk-2RK2AG32.js";
 import "../chunk-P5EPF6MB.js";
-import "../chunk-RXEIQ3KQ.js";
+import "../chunk-TMZMN7OS.js";
+import "../chunk-5GZFTAL7.js";
+import "../chunk-HRLWZGMA.js";
+import "../chunk-ITPEXLHA.js";
 import "../chunk-MXSSG3QU.js";
-import "../chunk-DEFBIVQ3.js";
-import "../chunk-3PJIGGWV.js";
+import "../chunk-IOALNTAN.js";
+import "../chunk-2CDEETQN.js";
 import "../chunk-FHFUXL6G.js";
-import "../chunk-NAMFB7ZA.js";
+import "../chunk-Z2XBWN7A.js";
 export {
   observeCommand,
   registerObserveCommand

package/dist/commands/project.d.ts

@@ -0,0 +1,85 @@
+import { ProjectStatus, Project } from '../lib/project-utils.js';
+import '../lib/task-utils.js';
+
+/**
+ * Project command for ClawVault
+ * Manages project add/update/archive/list/show/tasks/board operations
+ */
+
+interface ProjectAddOptions {
+    status?: ProjectStatus;
+    owner?: string;
+    team?: string[];
+    client?: string;
+    tags?: string[];
+    description?: string;
+    deadline?: string;
+    repo?: string;
+    url?: string;
+    content?: string;
+}
+interface ProjectUpdateOptions {
+    status?: ProjectStatus;
+    owner?: string | null;
+    team?: string[] | null;
+    client?: string | null;
+    tags?: string[] | null;
+    description?: string | null;
+    deadline?: string | null;
+    repo?: string | null;
+    url?: string | null;
+}
+interface ProjectArchiveOptions {
+    reason?: string;
+}
+interface ProjectListOptions {
+    status?: ProjectStatus;
+    owner?: string;
+    client?: string;
+    tag?: string;
+    json?: boolean;
+}
+interface ProjectShowOptions {
+    json?: boolean;
+}
+interface ProjectTasksOptions {
+    json?: boolean;
+}
+type ProjectBoardGroupBy = 'status' | 'owner' | 'client';
+interface ProjectBoardOptions {
+    output?: string;
+    groupBy?: ProjectBoardGroupBy | string;
+    now?: Date;
+}
+interface ProjectBoardLane {
+    name: string;
+    cards: string[];
+}
+interface ProjectBoardResult {
+    outputPath: string;
+    groupBy: ProjectBoardGroupBy;
+    markdown: string;
+    lanes: ProjectBoardLane[];
+    projectCount: number;
+}
+declare function buildProjectBoardLanes(projects: Project[], groupBy: ProjectBoardGroupBy): ProjectBoardLane[];
+declare function generateProjectBoardMarkdown(projects: Project[], options?: {
+    groupBy?: ProjectBoardGroupBy | string;
+    now?: Date;
+}): string;
+declare function syncProjectBoard(vaultPath: string, options?: ProjectBoardOptions): ProjectBoardResult;
+declare function projectAdd(vaultPath: string, title: string, options?: ProjectAddOptions): Project;
+declare function projectUpdate(vaultPath: string, slug: string, options: ProjectUpdateOptions): Project;
+declare function projectArchive(vaultPath: string, slug: string, options?: ProjectArchiveOptions): Project;
+declare function projectList(vaultPath: string, options?: ProjectListOptions): Project[];
+declare function formatProjectList(projects: Project[]): string;
+declare function formatProjectDetails(vaultPath: string, project: Project, options?: {
+    activityLimit?: number;
+}): string;
+declare function projectCommand(vaultPath: string, action: 'add' | 'update' | 'archive' | 'list' | 'show' | 'tasks' | 'board', args: {
+    title?: string;
+    slug?: string;
+    options?: ProjectAddOptions & ProjectUpdateOptions & ProjectArchiveOptions & ProjectListOptions & ProjectShowOptions & ProjectTasksOptions & ProjectBoardOptions;
+}): Promise<void>;
+
+export { type ProjectAddOptions, type ProjectArchiveOptions, type ProjectBoardGroupBy, type ProjectBoardLane, type ProjectBoardOptions, type ProjectBoardResult, type ProjectListOptions, type ProjectShowOptions, type ProjectTasksOptions, type ProjectUpdateOptions, buildProjectBoardLanes, formatProjectDetails, formatProjectList, generateProjectBoardMarkdown, projectAdd, projectArchive, projectCommand, projectList, projectUpdate, syncProjectBoard };

package/dist/commands/project.js

@@ -0,0 +1,411 @@
+import {
+  formatTaskList,
+  taskList
+} from "../chunk-YCVDVI5B.js";
+import {
+  archiveProject,
+  createProject,
+  getProjectActivity,
+  getProjectTasks,
+  listProjects,
+  readProject,
+  updateProject
+} from "../chunk-5GZFTAL7.js";
+import "../chunk-IOALNTAN.js";
+
+// src/commands/project.ts
+import * as fs from "fs";
+import * as path from "path";
+function toDateStr(value) {
+  if (!value) return "-";
+  return value.includes("T") ? value.split("T")[0] : value;
+}
+function toHashTag(value) {
+  return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9/_-]/g, "");
+}
+function toMention(value) {
+  return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9._-]/g, "");
+}
+function normalizeBoardGroupBy(value) {
+  const normalized = String(value || "status").trim().toLowerCase();
+  if (normalized === "status" || normalized === "owner" || normalized === "client") {
+    return normalized;
+  }
+  throw new Error(`Unsupported project board group field: ${normalized}`);
+}
+function resolveBoardPath(vaultPath, output) {
+  const resolvedVaultPath = path.resolve(vaultPath);
+  if (!output) {
+    return path.join(resolvedVaultPath, "Projects-Board.md");
+  }
+  if (path.isAbsolute(output)) {
+    return output;
+  }
+  return path.join(resolvedVaultPath, output);
+}
+function parseDeadlineTimestamp(project) {
+  if (!project.frontmatter.deadline) return Number.POSITIVE_INFINITY;
+  const timestamp = Date.parse(project.frontmatter.deadline);
+  return Number.isNaN(timestamp) ? Number.POSITIVE_INFINITY : timestamp;
+}
+function sortProjectsForCards(projects) {
+  return [...projects].sort((left, right) => {
+    const deadlineDiff = parseDeadlineTimestamp(left) - parseDeadlineTimestamp(right);
+    if (deadlineDiff !== 0) return deadlineDiff;
+    return new Date(right.frontmatter.updated).getTime() - new Date(left.frontmatter.updated).getTime();
+  });
+}
+function laneNameForStatus(status) {
+  switch (status) {
+    case "active":
+      return "Active";
+    case "paused":
+      return "Paused";
+    case "completed":
+      return "Completed";
+    case "archived":
+      return "Archived";
+    default:
+      return "Active";
+  }
+}
+function laneNameForProject(project, groupBy) {
+  switch (groupBy) {
+    case "status":
+      return laneNameForStatus(project.frontmatter.status);
+    case "owner":
+      return project.frontmatter.owner?.trim() || "Unassigned";
+    case "client":
+      return project.frontmatter.client?.trim() || "No Client";
+    default:
+      return laneNameForStatus(project.frontmatter.status);
+  }
+}
+function defaultLaneOrder(groupBy, projects) {
+  if (groupBy === "status") {
+    return ["Active", "Paused", "Completed", "Archived"];
+  }
+  const fallback = groupBy === "owner" ? "Unassigned" : "No Client";
+  const names = /* @__PURE__ */ new Set();
+  for (const project of projects) {
+    names.add(laneNameForProject(project, groupBy));
+  }
+  if (names.size === 0) {
+    return [fallback];
+  }
+  const sorted = Array.from(names).sort((left, right) => left.localeCompare(right));
+  if (sorted.includes(fallback)) {
+    return [...sorted.filter((name) => name !== fallback), fallback];
+  }
+  return sorted;
+}
+function formatProjectCard(project) {
+  const checkbox = project.frontmatter.status === "completed" || project.frontmatter.status === "archived" ? "x" : " ";
+  const parts = [`[[projects/${project.slug}|${project.title}]]`];
+  if (project.frontmatter.owner) {
+    const mention = toMention(project.frontmatter.owner);
+    if (mention) parts.push(`@${mention}`);
+  }
+  if (project.frontmatter.client) {
+    const clientTag = toHashTag(project.frontmatter.client);
+    if (clientTag) parts.push(`#client/${clientTag}`);
+  }
+  if (project.frontmatter.tags && project.frontmatter.tags.length > 0) {
+    for (const tag of project.frontmatter.tags) {
+      const normalizedTag = toHashTag(tag);
+      if (normalizedTag) parts.push(`#${normalizedTag}`);
+    }
+  }
+  if (project.frontmatter.deadline) {
+    parts.push(`\u{1F4C5} ${toDateStr(project.frontmatter.deadline)}`);
+  }
+  if (project.frontmatter.description) {
+    parts.push(`\u2014 ${project.frontmatter.description}`);
+  }
+  return `- [${checkbox}] ${parts.join(" ")}`;
+}
+function buildProjectBoardLanes(projects, groupBy) {
+  const laneOrder = defaultLaneOrder(groupBy, projects);
+  const lanes = /* @__PURE__ */ new Map();
+  for (const laneName of laneOrder) {
+    lanes.set(laneName, []);
+  }
+  for (const project of sortProjectsForCards(projects)) {
+    const laneName = laneNameForProject(project, groupBy);
+    if (!lanes.has(laneName)) {
+      lanes.set(laneName, []);
+    }
+    lanes.get(laneName)?.push(formatProjectCard(project));
+  }
+  return Array.from(lanes.entries()).map(([name, cards]) => ({ name, cards }));
+}
+function generateProjectBoardMarkdown(projects, options = {}) {
+  const groupBy = normalizeBoardGroupBy(options.groupBy);
+  const syncedAt = (options.now || /* @__PURE__ */ new Date()).toISOString();
+  const lanes = buildProjectBoardLanes(projects, groupBy);
+  const sections = lanes.map((lane) => {
+    const cardsBlock = lane.cards.length > 0 ? lane.cards.join("\n") : "";
+    return `## ${lane.name}
+
+${cardsBlock}`.trimEnd();
+  }).join("\n\n");
+  return [
+    "---",
+    "kanban-plugin: basic",
+    `clawvault-group-by: ${groupBy}`,
+    `clawvault-last-sync: '${syncedAt}'`,
+    "---",
+    "",
+    sections,
+    "",
+    "%% kanban:settings",
+    '{"kanban-plugin":"basic","list-collapse":["Completed","Archived"],"show-checkboxes":true}',
+    "%%",
+    ""
+  ].join("\n");
+}
+function syncProjectBoard(vaultPath, options = {}) {
+  const groupBy = normalizeBoardGroupBy(options.groupBy);
+  const outputPath = resolveBoardPath(vaultPath, options.output);
+  const projects = listProjects(vaultPath);
+  const markdown = generateProjectBoardMarkdown(projects, { groupBy, now: options.now });
+  fs.writeFileSync(outputPath, markdown);
+  return {
+    outputPath,
+    groupBy,
+    markdown,
+    lanes: buildProjectBoardLanes(projects, groupBy),
+    projectCount: projects.length
+  };
+}
+function projectAdd(vaultPath, title, options = {}) {
+  return createProject(vaultPath, title, {
+    status: options.status,
+    owner: options.owner,
+    team: options.team,
+    client: options.client,
+    tags: options.tags,
+    description: options.description,
+    deadline: options.deadline,
+    repo: options.repo,
+    url: options.url,
+    content: options.content
+  });
+}
+function projectUpdate(vaultPath, slug, options) {
+  return updateProject(vaultPath, slug, {
+    status: options.status,
+    owner: options.owner,
+    team: options.team,
+    client: options.client,
+    tags: options.tags,
+    description: options.description,
+    deadline: options.deadline,
+    repo: options.repo,
+    url: options.url
+  });
+}
+function projectArchive(vaultPath, slug, options = {}) {
+  return archiveProject(vaultPath, slug, options.reason);
+}
+function projectList(vaultPath, options = {}) {
+  const projects = listProjects(vaultPath, {
+    status: options.status,
+    owner: options.owner,
+    client: options.client,
+    tag: options.tag
+  });
+  if (!options.status) {
+    return projects.filter((project) => project.frontmatter.status !== "archived");
+  }
+  return projects;
+}
+function formatProjectList(projects) {
+  if (projects.length === 0) {
+    return "No projects found.\n";
+  }
+  const headers = ["STATUS", "OWNER", "DEADLINE", "TITLE"];
+  const widths = [10, 12, 12, 40];
+  const truncate = (value, width) => {
+    if (value.length <= width) return value;
+    return value.slice(0, width - 3) + "...";
+  };
+  let output = headers.map((header, index) => header.padEnd(widths[index])).join("  ") + "\n";
+  for (const project of projects) {
+    const row = [
+      project.frontmatter.status.padEnd(widths[0]),
+      (project.frontmatter.owner || "-").padEnd(widths[1]),
+      toDateStr(project.frontmatter.deadline).padEnd(widths[2]),
+      truncate(project.title, widths[3])
+    ];
+    output += row.join("  ") + "\n";
+  }
+  return output;
+}
+function formatFieldValue(value) {
+  if (Array.isArray(value)) {
+    return value.join(", ");
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return "-";
+  }
+  return String(value);
+}
+function countTasksByStatus(projectSlug, vaultPath) {
+  const tasks = getProjectTasks(vaultPath, projectSlug);
+  return {
+    open: tasks.filter((task) => task.frontmatter.status === "open").length,
+    inProgress: tasks.filter((task) => task.frontmatter.status === "in-progress").length,
+    done: tasks.filter((task) => task.frontmatter.status === "done").length
+  };
+}
+function formatProjectDetails(vaultPath, project, options = {}) {
+  const lines = [];
+  const taskSummary = countTasksByStatus(project.slug, vaultPath);
+  const activity = getProjectActivity(vaultPath, project.slug).slice(0, options.activityLimit ?? 5);
+  lines.push(`# ${project.title}`);
+  lines.push("-".repeat(40));
+  const orderedFields = [
+    "type",
+    "status",
+    "owner",
+    "team",
+    "client",
+    "tags",
+    "description",
+    "started",
+    "deadline",
+    "repo",
+    "url",
+    "created",
+    "updated",
+    "completed",
+    "reason"
+  ];
+  for (const field of orderedFields) {
+    const value = project.frontmatter[field];
+    if (value === void 0) continue;
+    lines.push(`${field}: ${formatFieldValue(value)}`);
+  }
+  lines.push("");
+  lines.push(`Linked tasks: ${taskSummary.open} open, ${taskSummary.inProgress} in-progress, ${taskSummary.done} done`);
+  if (project.frontmatter.team && project.frontmatter.team.length > 0) {
+    lines.push("Team members:");
+    for (const member of project.frontmatter.team) {
+      lines.push(`- ${member}`);
+    }
+  }
+  lines.push("");
+  lines.push("Recent activity:");
+  if (activity.length === 0) {
+    lines.push("- none");
+  } else {
+    for (const filePath of activity) {
+      lines.push(`- ${path.basename(filePath)}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function projectCommand(vaultPath, action, args) {
+  const options = args.options || {};
+  switch (action) {
+    case "add": {
+      if (!args.title) {
+        throw new Error("Title is required for project add");
+      }
+      const project = projectAdd(vaultPath, args.title, options);
+      console.log(`\u2713 Created project: ${project.slug}`);
+      console.log(`  Path: ${path.join(path.resolve(vaultPath), "projects", `${project.slug}.md`)}`);
+      break;
+    }
+    case "update": {
+      if (!args.slug) {
+        throw new Error("Project slug is required for update");
+      }
+      const project = projectUpdate(vaultPath, args.slug, options);
+      console.log(`\u2713 Updated project: ${project.slug}`);
+      break;
+    }
+    case "archive": {
+      if (!args.slug) {
+        throw new Error("Project slug is required for archive");
+      }
+      const project = projectArchive(vaultPath, args.slug, options);
+      console.log(`\u2713 Archived project: ${project.slug}`);
+      break;
+    }
+    case "list": {
+      const projects = projectList(vaultPath, options);
+      if (options.json) {
+        console.log(JSON.stringify(projects, null, 2));
+      } else {
+        console.log(formatProjectList(projects));
+      }
+      break;
+    }
+    case "show": {
+      if (!args.slug) {
+        throw new Error("Project slug is required for show");
+      }
+      const project = readProject(vaultPath, args.slug);
+      if (!project) {
+        throw new Error(`Project not found: ${args.slug}`);
+      }
+      const taskSummary = countTasksByStatus(project.slug, vaultPath);
+      const recentActivity = getProjectActivity(vaultPath, project.slug).slice(0, 5);
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              project,
+              taskSummary,
+              team: project.frontmatter.team || [],
+              recentActivity
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log(formatProjectDetails(vaultPath, project, { activityLimit: 5 }));
+      }
+      break;
+    }
+    case "tasks": {
+      if (!args.slug) {
+        throw new Error("Project slug is required for tasks");
+      }
+      const tasks = taskList(vaultPath, { project: args.slug });
+      if (options.json) {
+        console.log(JSON.stringify(tasks, null, 2));
+      } else {
+        console.log(formatTaskList(tasks));
+      }
+      break;
+    }
+    case "board": {
+      const result = syncProjectBoard(vaultPath, options);
+      console.log(`\u2713 Synced project board: ${result.outputPath}`);
+      console.log(`  Grouped by: ${result.groupBy}`);
+      console.log(`  Projects included: ${result.projectCount}`);
+      break;
+    }
+    default:
+      throw new Error(`Unknown project action: ${action}`);
+  }
+}
+export {
+  buildProjectBoardLanes,
+  formatProjectDetails,
+  formatProjectList,
+  generateProjectBoardMarkdown,
+  projectAdd,
+  projectArchive,
+  projectCommand,
+  projectList,
+  projectUpdate,
+  syncProjectBoard
+};