@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-CSD7IHSN.js

@@ -1,152 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/task-loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var TASKS_ROOT = ".paradigm/tasks";
-var ENTRIES_DIR = "entries";
-var INDEX_FILE = "index.yaml";
-function generateTaskId(rootDir, dateStr) {
-  const datePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr);
-  if (!fs.existsSync(datePath)) {
-    return `T-${dateStr}-001`;
-  }
-  const existing = fs.readdirSync(datePath).filter((f) => f.startsWith("T-") && f.endsWith(".yaml")).map((f) => {
-    const match = f.match(/T-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
-    return match ? parseInt(match[1], 10) : 0;
-  });
-  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
-  return `T-${dateStr}-${String(next).padStart(3, "0")}`;
-}
-var PRIORITY_ORDER = { high: 0, medium: 1, low: 2 };
-function applyFilter(tasks, filter) {
-  let result = tasks;
-  if (filter.status && filter.status !== "all") {
-    result = result.filter((t) => t.status === filter.status);
-  }
-  if (filter.priority) {
-    result = result.filter((t) => t.priority === filter.priority);
-  }
-  if (filter.tag) {
-    result = result.filter((t) => t.tags.includes(filter.tag));
-  }
-  result.sort((a, b) => {
-    const priDiff = (PRIORITY_ORDER[a.priority] ?? 1) - (PRIORITY_ORDER[b.priority] ?? 1);
-    if (priDiff !== 0) return priDiff;
-    return new Date(b.created).getTime() - new Date(a.created).getTime();
-  });
-  if (filter.limit) {
-    result = result.slice(0, filter.limit);
-  }
-  return result;
-}
-async function loadTasks(rootDir, filter) {
-  const entriesPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR);
-  if (!fs.existsSync(entriesPath)) return [];
-  const effectiveFilter = { status: "open", limit: 20, ...filter };
-  const tasks = [];
-  const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
-  for (const dateDir of dateDirs) {
-    const dirPath = path.join(entriesPath, dateDir);
-    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
-        const task = yaml.load(content);
-        tasks.push(task);
-      } catch {
-      }
-    }
-  }
-  return applyFilter(tasks, effectiveFilter);
-}
-async function loadTask(rootDir, taskId) {
-  const dateMatch = taskId.match(/^T-(\d{4}-\d{2}-\d{2})-/);
-  if (dateMatch) {
-    const filePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateMatch[1], `${taskId}.yaml`);
-    if (fs.existsSync(filePath)) {
-      try {
-        return yaml.load(fs.readFileSync(filePath, "utf8"));
-      } catch {
-        return null;
-      }
-    }
-  }
-  const tasks = await loadTasks(rootDir, { status: "all", limit: 9999 });
-  return tasks.find((t) => t.id === taskId) || null;
-}
-async function createTask(rootDir, task) {
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().slice(0, 10);
-  const datePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr);
-  fs.mkdirSync(datePath, { recursive: true });
-  const id = generateTaskId(rootDir, dateStr);
-  const entry = {
-    id,
-    blurb: task.blurb,
-    priority: task.priority || "medium",
-    status: "open",
-    tags: task.tags || [],
-    created: now.toISOString(),
-    session_link: task.session_link,
-    related_lore: task.related_lore
-  };
-  fs.writeFileSync(path.join(datePath, `${id}.yaml`), yaml.dump(entry, { lineWidth: -1, noRefs: true }));
-  await rebuildTaskIndex(rootDir);
-  return id;
-}
-async function updateTask(rootDir, taskId, partial) {
-  const task = await loadTask(rootDir, taskId);
-  if (!task) return false;
-  const dateStr = task.created.slice(0, 10);
-  const taskPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr, `${taskId}.yaml`);
-  if (!fs.existsSync(taskPath)) return false;
-  const { id: _id, created: _created, ...safePartial } = partial;
-  const updated = { ...task, ...safePartial };
-  fs.writeFileSync(taskPath, yaml.dump(updated, { lineWidth: -1, noRefs: true }));
-  await rebuildTaskIndex(rootDir);
-  return true;
-}
-async function completeTask(rootDir, taskId) {
-  return updateTask(rootDir, taskId, { status: "done", completed: (/* @__PURE__ */ new Date()).toISOString() });
-}
-async function shelveTask(rootDir, taskId) {
-  return updateTask(rootDir, taskId, { status: "shelved", shelved: (/* @__PURE__ */ new Date()).toISOString() });
-}
-async function rebuildTaskIndex(rootDir) {
-  const entriesPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR);
-  const tasksRootPath = path.join(rootDir, TASKS_ROOT);
-  let total = 0, open = 0, done = 0, shelved = 0;
-  if (fs.existsSync(entriesPath)) {
-    const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
-    for (const dateDir of dateDirs) {
-      const dirPath = path.join(entriesPath, dateDir);
-      const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
-      for (const file of files) {
-        try {
-          const task = yaml.load(fs.readFileSync(path.join(dirPath, file), "utf8"));
-          total++;
-          if (task.status === "open") open++;
-          else if (task.status === "done") done++;
-          else if (task.status === "shelved") shelved++;
-        } catch {
-        }
-      }
-    }
-  }
-  const index = { version: "1.0", total, open, done, shelved, last_updated: (/* @__PURE__ */ new Date()).toISOString() };
-  fs.mkdirSync(tasksRootPath, { recursive: true });
-  fs.writeFileSync(path.join(tasksRootPath, INDEX_FILE), yaml.dump(index, { lineWidth: -1, noRefs: true }));
-  return index;
-}
-
-export {
-  loadTasks,
-  loadTask,
-  createTask,
-  updateTask,
-  completeTask,
-  shelveTask,
-  rebuildTaskIndex
-};