@kmgeon/taskflow 0.1.3

package/src/features/taskflow/lib/repository.ts

@@ -0,0 +1,168 @@
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import {
+  getTasksDir,
+  getTaskflowRoot,
+  getTaskFilePath,
+  extractTaskId,
+  TASK_FILE_PREFIX,
+  TASK_FILE_EXT,
+} from "../constants";
+import type { Task, TaskCreateInput, TaskFilter, TaskSortKey, TaskSortOrder, TaskUpdateInput } from "../types";
+import { atomicWrite, ensureDir, safeReadFile, safeRemove } from "./fs-utils";
+import { parseTask, serializeTask } from "./serializer";
+import { rebuildIndex } from "./index-builder";
+import { filterTasks, sortTasks } from "./filter";
+
+function generateId(): string {
+  const num = crypto.randomInt(0, 1000).toString().padStart(3, "0");
+  return num;
+}
+
+async function findNextId(projectRoot: string): Promise<string> {
+  const tasksDir = getTasksDir(projectRoot);
+  const files = await listTaskFiles(tasksDir);
+  const existingIds = files
+    .map(extractTaskId)
+    .filter(Boolean)
+    .map((id) => parseInt(id!, 10))
+    .filter((n) => !Number.isNaN(n));
+
+  const maxId = existingIds.length > 0 ? Math.max(...existingIds) : 0;
+  return String(maxId + 1).padStart(3, "0");
+}
+
+async function listTaskFiles(tasksDir: string): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(tasksDir);
+    return entries.filter(
+      (f) => f.startsWith(TASK_FILE_PREFIX) && f.endsWith(TASK_FILE_EXT),
+    );
+  } catch {
+    return [];
+  }
+}
+
+export async function ensureRepo(projectRoot: string): Promise<void> {
+  const root = getTaskflowRoot(projectRoot);
+  await ensureDir(root);
+  await ensureDir(getTasksDir(projectRoot));
+  await ensureDir(`${root}/index`);
+  await ensureDir(`${root}/logs`);
+  await ensureDir(`${root}/cache`);
+}
+
+export async function readTask(projectRoot: string, id: string): Promise<Task | null> {
+  const filePath = getTaskFilePath(projectRoot, id);
+  const content = await safeReadFile(filePath);
+  if (!content) return null;
+  return parseTask(content);
+}
+
+export async function listTasks(
+  projectRoot: string,
+  options?: {
+    filter?: TaskFilter;
+    sortKey?: TaskSortKey;
+    sortOrder?: TaskSortOrder;
+  },
+): Promise<Task[]> {
+  const tasksDir = getTasksDir(projectRoot);
+  const files = await listTaskFiles(tasksDir);
+
+  const tasks: Task[] = [];
+  for (const file of files) {
+    const content = await safeReadFile(`${tasksDir}/${file}`);
+    if (!content) continue;
+
+    try {
+      tasks.push(parseTask(content));
+    } catch {
+      // skip malformed task files
+    }
+  }
+
+  const filtered = options?.filter ? filterTasks(tasks, options.filter) : tasks;
+  return sortTasks(filtered, options?.sortKey, options?.sortOrder);
+}
+
+export async function createTask(
+  projectRoot: string,
+  input: TaskCreateInput,
+): Promise<Task> {
+  await ensureRepo(projectRoot);
+  const id = await findNextId(projectRoot);
+  const now = new Date().toISOString();
+
+  const task: Task = {
+    id,
+    title: input.title,
+    status: input.status ?? "Todo",
+    priority: input.priority ?? 0,
+    dependencies: input.dependencies ?? [],
+    parentId: input.parentId,
+    group: input.group,
+    createdAt: now,
+    updatedAt: now,
+    description: input.description ?? "",
+  };
+
+  const filePath = getTaskFilePath(projectRoot, id);
+  await atomicWrite(filePath, serializeTask(task));
+
+  const allTasks = await listTasks(projectRoot);
+  await rebuildIndex(projectRoot, allTasks);
+
+  return task;
+}
+
+export async function updateTask(
+  projectRoot: string,
+  id: string,
+  patch: TaskUpdateInput,
+): Promise<Task> {
+  const existing = await readTask(projectRoot, id);
+  if (!existing) {
+    throw new Error(`Task not found: ${id}`);
+  }
+
+  const updated: Task = {
+    ...existing,
+    ...patch,
+    id: existing.id,
+    createdAt: existing.createdAt,
+    updatedAt: new Date().toISOString(),
+  };
+
+  const filePath = getTaskFilePath(projectRoot, id);
+  await atomicWrite(filePath, serializeTask(updated));
+
+  const allTasks = await listTasks(projectRoot);
+  await rebuildIndex(projectRoot, allTasks);
+
+  return updated;
+}
+
+export async function deleteTask(projectRoot: string, id: string): Promise<boolean> {
+  const filePath = getTaskFilePath(projectRoot, id);
+  const removed = await safeRemove(filePath);
+
+  if (removed) {
+    const allTasks = await listTasks(projectRoot);
+    await rebuildIndex(projectRoot, allTasks);
+  }
+
+  return removed;
+}
+
+export async function searchTasks(projectRoot: string, query: string): Promise<Task[]> {
+  const allTasks = await listTasks(projectRoot);
+  const lowerQuery = query.toLowerCase();
+
+  return allTasks.filter(
+    (task) =>
+      task.title.toLowerCase().includes(lowerQuery) ||
+      task.description.toLowerCase().includes(lowerQuery) ||
+      task.id.includes(lowerQuery),
+  );
+}

package/src/features/taskflow/lib/serializer.ts

@@ -0,0 +1,62 @@
+import matter from "gray-matter";
+import type { Task, TaskStatus } from "../types";
+import { TASK_STATUSES } from "../types";
+
+interface TaskFrontmatter {
+  id: string;
+  title: string;
+  status: string;
+  priority?: number;
+  dependencies?: string[];
+  parentId?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+function isValidStatus(value: string): value is TaskStatus {
+  return (TASK_STATUSES as readonly string[]).includes(value);
+}
+
+export function parseTask(raw: string): Task {
+  const { data, content } = matter(raw);
+  const fm = data as TaskFrontmatter;
+
+  if (!fm.id || !fm.title) {
+    throw new Error(`Invalid task: missing required fields (id, title)`);
+  }
+
+  const status = isValidStatus(fm.status) ? fm.status : "Todo";
+
+  return {
+    id: fm.id,
+    title: fm.title,
+    status,
+    priority: fm.priority ?? 0,
+    dependencies: fm.dependencies ?? [],
+    parentId: fm.parentId,
+    createdAt: fm.createdAt ?? new Date().toISOString(),
+    updatedAt: fm.updatedAt ?? new Date().toISOString(),
+    description: content.trim(),
+  };
+}
+
+export function serializeTask(task: Task): string {
+  const frontmatter: Record<string, unknown> = {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+  };
+
+  if (task.dependencies.length > 0) {
+    frontmatter.dependencies = task.dependencies;
+  }
+
+  if (task.parentId) {
+    frontmatter.parentId = task.parentId;
+  }
+
+  return matter.stringify(task.description || "", frontmatter);
+}

package/src/features/taskflow/lib/watcher.ts

@@ -0,0 +1,40 @@
+import { watch, type FSWatcher } from "chokidar";
+import path from "node:path";
+import { getTasksDir, extractTaskId } from "../constants";
+
+export type WatchEvent = "created" | "updated" | "deleted";
+
+export interface TaskFileEvent {
+  event: WatchEvent;
+  taskId: string;
+  filePath: string;
+}
+
+export type TaskFileEventHandler = (event: TaskFileEvent) => void;
+
+export function createTaskWatcher(
+  projectRoot: string,
+  onEvent: TaskFileEventHandler,
+): FSWatcher {
+  const tasksDir = getTasksDir(projectRoot);
+  const glob = path.join(tasksDir, "task-*.md");
+
+  const watcher = watch(glob, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+  });
+
+  function handleEvent(event: WatchEvent) {
+    return (filePath: string) => {
+      const taskId = extractTaskId(path.basename(filePath));
+      if (!taskId) return;
+      onEvent({ event, taskId, filePath });
+    };
+  }
+
+  watcher.on("add", handleEvent("created"));
+  watcher.on("change", handleEvent("updated"));
+  watcher.on("unlink", handleEvent("deleted"));
+
+  return watcher;
+}

package/src/features/taskflow/types.ts

@@ -0,0 +1,71 @@
+export const TASK_STATUSES = ["Todo", "InProgress", "Blocked", "Done"] as const;
+
+export type TaskStatus = (typeof TASK_STATUSES)[number];
+
+export interface Task {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  priority: number;
+  dependencies: string[];
+  parentId?: string;
+  group?: string;
+  createdAt: string;
+  updatedAt: string;
+  description: string;
+}
+
+export type TaskCreateInput = Pick<Task, "title"> &
+  Partial<Omit<Task, "id" | "title" | "createdAt" | "updatedAt">>;
+
+export type TaskUpdateInput = Partial<Omit<Task, "id" | "createdAt">>;
+
+export interface TaskFilter {
+  status?: TaskStatus | TaskStatus[];
+  priority?: number;
+  parentId?: string;
+  updatedSince?: string;
+  hasDependency?: string;
+}
+
+export type TaskSortKey = "priority" | "status" | "createdAt" | "updatedAt" | "title";
+
+export type TaskSortOrder = "asc" | "desc";
+
+// Advisor types
+export type SessionType = "prd" | "parse-prd" | "trd" | "brainstorm" | "ask" | "refine";
+
+export interface ConvLog {
+  id: number;
+  sessionType: SessionType;
+  sessionId: string;
+  role: "user" | "assistant";
+  content: string;
+  createdAt: string;
+}
+
+export interface Decision {
+  id: number;
+  sessionId: string;
+  decision: string;
+  reason: string;
+  relatedTasks: string[];
+  createdAt: string;
+}
+
+export interface TaskSummary {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  priority: number;
+  dependencies: string[];
+}
+
+export interface AdvisorContext {
+  tasks: TaskSummary[];
+  decisions: Decision[];
+  trdContent?: string;
+  prdContent?: string;
+  gitDiff?: string;
+  conversationLogs?: ConvLog[];
+}

package/src/hooks/use-toast.ts

@@ -0,0 +1,194 @@
+"use client"
+
+// Inspired by react-hot-toast library
+import * as React from "react"
+
+import type {
+  ToastActionElement,
+  ToastProps,
+} from "@/components/ui/toast"
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = ToastProps & {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: ToastActionElement
+}
+
+const actionTypes = {
+  ADD_TOAST: "ADD_TOAST",
+  UPDATE_TOAST: "UPDATE_TOAST",
+  DISMISS_TOAST: "DISMISS_TOAST",
+  REMOVE_TOAST: "REMOVE_TOAST",
+} as const
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = typeof actionTypes
+
+type Action =
+  | {
+      type: ActionType["ADD_TOAST"]
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType["UPDATE_TOAST"]
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType["DISMISS_TOAST"]
+      toastId?: ToasterToast["id"]
+    }
+  | {
+      type: ActionType["REMOVE_TOAST"]
+      toastId?: ToasterToast["id"]
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t
+        ),
+      }
+
+    case "DISMISS_TOAST": {
+      const { toastId } = action
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t
+        ),
+      }
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, "id">
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: "UPDATE_TOAST",
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
+
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+  }
+}
+
+export { useToast, toast }

package/src/lib/remote/api-client.ts

@@ -0,0 +1,40 @@
+import axios, { isAxiosError } from "axios";
+
+const apiClient = axios.create({
+  baseURL: process.env.NEXT_PUBLIC_API_BASE_URL ?? "",
+  headers: {
+    "Content-Type": "application/json",
+  },
+});
+
+type ErrorPayload = {
+  error?: {
+    message?: string;
+  };
+  message?: string;
+};
+
+export const extractApiErrorMessage = (
+  error: unknown,
+  fallbackMessage = "API request failed."
+) => {
+  if (isAxiosError(error)) {
+    const payload = error.response?.data as ErrorPayload | undefined;
+
+    if (typeof payload?.error?.message === "string") {
+      return payload.error.message;
+    }
+
+    if (typeof payload?.message === "string") {
+      return payload.message;
+    }
+  }
+
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+
+  return fallbackMessage;
+};
+
+export { apiClient, isAxiosError };

package/src/lib/supabase/client.ts

@@ -0,0 +1,8 @@
+import { createBrowserClient } from "@supabase/ssr";
+
+export function createClient() {
+  return createBrowserClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
+  );
+}

package/src/lib/supabase/server.ts

@@ -0,0 +1,46 @@
+import "server-only";
+
+import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+
+export async function createClient() {
+  const cookieStore = await cookies();
+
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.SUPABASE_SERVICE_ROLE_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(({ name, value, options }) =>
+              cookieStore.set(name, value, options)
+            );
+          } catch {
+            // The `setAll` method was called from a Server Component.
+            // This can be ignored if you have middleware refreshing
+            // user sessions.
+          }
+        },
+      },
+    }
+  );
+}
+
+export async function createPureClient() {
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.SUPABASE_SERVICE_ROLE_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return [];
+        },
+        setAll() {},
+      },
+    }
+  );
+}

package/src/lib/supabase/types.ts

@@ -0,0 +1,3 @@
+export type Database = Record<string, never>;
+
+export type SupabaseUserMetadata = Record<string, unknown>;

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/mcp/index.ts

@@ -0,0 +1,7 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createMcpServer } from "./server.js";
+
+const server = createMcpServer();
+const transport = new StdioServerTransport();
+
+await server.connect(transport);

package/src/mcp/server.ts

@@ -0,0 +1,21 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerProjectTools } from "./tools/project.js";
+import { registerTaskTools } from "./tools/task.js";
+import { registerTaskStatusTools } from "./tools/task-status.js";
+import { registerPrdTools } from "./tools/prd.js";
+import { registerBrainstormTools } from "./tools/brainstorm.js";
+
+export function createMcpServer(): McpServer {
+  const server = new McpServer({
+    name: "taskflow",
+    version: "0.2.0",
+  });
+
+  registerProjectTools(server);
+  registerTaskTools(server);
+  registerTaskStatusTools(server);
+  registerPrdTools(server);
+  registerBrainstormTools(server);
+
+  return server;
+}