@kmgeon/taskflow 0.1.3

package/src/features/taskflow/lib/advisor/db.ts

@@ -0,0 +1,185 @@
+import initSqlJs, { type Database } from "sql.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { ConvLog, Decision, SessionType } from "../../types.js";
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS conversation_logs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_type TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS decisions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  decision TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  related_tasks TEXT NOT NULL DEFAULT '[]',
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_conv_session ON conversation_logs(session_type, session_id);
+CREATE INDEX IF NOT EXISTS idx_conv_created ON conversation_logs(created_at);
+CREATE INDEX IF NOT EXISTS idx_decisions_session ON decisions(session_id);
+`;
+
+export class AdvisorDb {
+  private db: Database;
+  private dbPath: string;
+
+  private constructor(db: Database, dbPath: string) {
+    this.db = db;
+    this.dbPath = dbPath;
+  }
+
+  static async open(dbPath: string): Promise<AdvisorDb> {
+    const SQL = await initSqlJs();
+
+    let db: Database;
+    try {
+      const buffer = await fs.readFile(dbPath);
+      db = new SQL.Database(buffer);
+    } catch {
+      db = new SQL.Database();
+    }
+
+    db.run(SCHEMA);
+    return new AdvisorDb(db, dbPath);
+  }
+
+  insertLog(
+    sessionType: SessionType,
+    sessionId: string,
+    role: "user" | "assistant",
+    content: string
+  ): void {
+    this.db.run(
+      "INSERT INTO conversation_logs (session_type, session_id, role, content) VALUES (?, ?, ?, ?)",
+      [sessionType, sessionId, role, content]
+    );
+  }
+
+  getLogsBySession(sessionId: string): ConvLog[] {
+    return this.queryLogs(
+      "SELECT * FROM conversation_logs WHERE session_id = ? ORDER BY id ASC",
+      [sessionId]
+    );
+  }
+
+  getLogsByType(sessionType: SessionType): ConvLog[] {
+    return this.queryLogs(
+      "SELECT * FROM conversation_logs WHERE session_type = ? ORDER BY id ASC",
+      [sessionType]
+    );
+  }
+
+  deleteExpiredLogs(days: number): number {
+    this.db.run(
+      "DELETE FROM conversation_logs WHERE created_at < datetime('now', ? || ' days')",
+      [`-${days}`]
+    );
+    return this.db.getRowsModified();
+  }
+
+  insertDecision(
+    sessionId: string,
+    decision: string,
+    reason: string,
+    relatedTasks: string[]
+  ): void {
+    this.db.run(
+      "INSERT INTO decisions (session_id, decision, reason, related_tasks) VALUES (?, ?, ?, ?)",
+      [sessionId, decision, reason, JSON.stringify(relatedTasks)]
+    );
+  }
+
+  getAllDecisions(): Decision[] {
+    return this.queryDecisions(
+      "SELECT * FROM decisions ORDER BY id DESC"
+    );
+  }
+
+  getRecentDecisions(limit: number): Decision[] {
+    return this.queryDecisions(
+      "SELECT * FROM decisions ORDER BY id DESC LIMIT ?",
+      [limit]
+    );
+  }
+
+  getStats(): { logCount: number; decisionCount: number; dbSizeBytes: number } {
+    const logRow = this.db.exec("SELECT COUNT(*) FROM conversation_logs");
+    const decisionRow = this.db.exec("SELECT COUNT(*) FROM decisions");
+    const data = this.db.export();
+
+    return {
+      logCount: Number(logRow[0]?.values[0]?.[0] ?? 0),
+      decisionCount: Number(decisionRow[0]?.values[0]?.[0] ?? 0),
+      dbSizeBytes: data.length,
+    };
+  }
+
+  async persistToDisk(): Promise<void> {
+    const data = this.db.export();
+    const buffer = Buffer.from(data);
+    await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
+    await fs.writeFile(this.dbPath, buffer);
+  }
+
+  persistToDiskAsync(): void {
+    this.persistToDisk().catch((err) => {
+      console.error("⚠️ advisor.db 디스크 저장 실패:", err);
+    });
+  }
+
+  exec(sql: string): void {
+    this.db.run(sql);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  private queryLogs(sql: string, params: unknown[] = []): ConvLog[] {
+    const stmt = this.db.prepare(sql);
+    stmt.bind(params);
+
+    const results: ConvLog[] = [];
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push({
+        id: Number(row.id),
+        sessionType: row.session_type as SessionType,
+        sessionId: String(row.session_id),
+        role: row.role as "user" | "assistant",
+        content: String(row.content),
+        createdAt: String(row.created_at),
+      });
+    }
+    stmt.free();
+    return results;
+  }
+
+  private queryDecisions(sql: string, params: unknown[] = []): Decision[] {
+    const stmt = this.db.prepare(sql);
+    stmt.bind(params);
+
+    const results: Decision[] = [];
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push({
+        id: Number(row.id),
+        sessionId: String(row.session_id),
+        decision: String(row.decision),
+        reason: String(row.reason),
+        relatedTasks: JSON.parse(String(row.related_tasks)),
+        createdAt: String(row.created_at),
+      });
+    }
+    stmt.free();
+    return results;
+  }
+}

package/src/features/taskflow/lib/advisor/local-summary.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "vitest";
+import { buildLocalSummary, formatStatusOutput } from "./local-summary.js";
+import type { Task } from "../../types.js";
+
+const makeTasks = (): Task[] => [
+  { id: "1", title: "Task A", status: "Done", priority: 5, dependencies: [], createdAt: "", updatedAt: "", description: "" },
+  { id: "2", title: "Task B", status: "Done", priority: 4, dependencies: ["1"], createdAt: "", updatedAt: "", description: "" },
+  { id: "3", title: "Task C", status: "InProgress", priority: 3, dependencies: [], createdAt: "", updatedAt: "", description: "" },
+  { id: "4", title: "Task D", status: "Todo", priority: 2, dependencies: ["3"], createdAt: "", updatedAt: "", description: "" },
+  { id: "5", title: "Task E", status: "Blocked", priority: 1, dependencies: [], createdAt: "", updatedAt: "", description: "" },
+];
+
+describe("buildLocalSummary", () => {
+  it("should calculate correct progress", () => {
+    const summary = buildLocalSummary(makeTasks());
+    expect(summary.total).toBe(5);
+    expect(summary.done).toBe(2);
+    expect(summary.progressPercent).toBe(40);
+  });
+
+  it("should group tasks by status", () => {
+    const summary = buildLocalSummary(makeTasks());
+    expect(summary.groups.Done).toHaveLength(2);
+    expect(summary.groups.InProgress).toHaveLength(1);
+    expect(summary.groups.Todo).toHaveLength(1);
+    expect(summary.groups.Blocked).toHaveLength(1);
+  });
+
+  it("should handle empty task list", () => {
+    const summary = buildLocalSummary([]);
+    expect(summary.total).toBe(0);
+    expect(summary.progressPercent).toBe(0);
+  });
+});
+
+describe("formatStatusOutput", () => {
+  it("should produce formatted output with all sections", () => {
+    const summary = buildLocalSummary(makeTasks());
+    const output = formatStatusOutput(summary);
+    expect(output).toContain("2/5");
+    expect(output).toContain("40%");
+    expect(output).toContain("Done");
+    expect(output).toContain("In Progress");
+    expect(output).toContain("Todo");
+    expect(output).toContain("Blocked");
+  });
+
+  it("should handle no tasks gracefully", () => {
+    const summary = buildLocalSummary([]);
+    const output = formatStatusOutput(summary);
+    expect(output).toContain("0/0");
+  });
+});

package/src/features/taskflow/lib/advisor/local-summary.ts

@@ -0,0 +1,72 @@
+import chalk from "chalk";
+import type { Task, TaskStatus } from "../../types.js";
+
+export interface LocalSummary {
+  total: number;
+  done: number;
+  inProgress: number;
+  todo: number;
+  blocked: number;
+  progressPercent: number;
+  groups: Record<TaskStatus, Task[]>;
+}
+
+export function buildLocalSummary(tasks: Task[]): LocalSummary {
+  const groups: Record<TaskStatus, Task[]> = {
+    Done: [],
+    InProgress: [],
+    Todo: [],
+    Blocked: [],
+  };
+
+  for (const task of tasks) {
+    groups[task.status].push(task);
+  }
+
+  const total = tasks.length;
+  const done = groups.Done.length;
+  const progressPercent = total === 0 ? 0 : Math.round((done / total) * 100);
+
+  return {
+    total,
+    done,
+    inProgress: groups.InProgress.length,
+    todo: groups.Todo.length,
+    blocked: groups.Blocked.length,
+    progressPercent,
+    groups,
+  };
+}
+
+const STATUS_DISPLAY: Record<TaskStatus, { icon: string; label: string; color: (s: string) => string }> = {
+  Done:       { icon: "✅", label: "Done",        color: chalk.green },
+  InProgress: { icon: "🔵", label: "In Progress", color: chalk.hex("#FFA500") },
+  Todo:       { icon: "⬜", label: "Todo",        color: chalk.yellow },
+  Blocked:    { icon: "🔴", label: "Blocked",     color: chalk.red },
+};
+
+const DISPLAY_ORDER: TaskStatus[] = ["Done", "InProgress", "Blocked", "Todo"];
+
+export function formatStatusOutput(summary: LocalSummary): string {
+  const lines: string[] = [];
+
+  lines.push(
+    chalk.bold(`📊 프로젝트 진행률: ${summary.done}/${summary.total} (${summary.progressPercent}%)`)
+  );
+  lines.push("");
+
+  for (const status of DISPLAY_ORDER) {
+    const tasks = summary.groups[status];
+    if (tasks.length === 0) continue;
+
+    const { icon, label, color } = STATUS_DISPLAY[status];
+    lines.push(color(`${icon} ${label} (${tasks.length})`));
+
+    for (const task of tasks) {
+      lines.push(chalk.gray(`  ${task.id}. ${task.title}`));
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

package/src/features/taskflow/lib/advisor/prompts.ts

@@ -0,0 +1,86 @@
+import type { AdvisorContext } from "../../types.js";
+import type { LocalSummary } from "./local-summary.js";
+
+export function buildStatusPrompt(context: AdvisorContext, summary: LocalSummary): string {
+  return `너는 프로젝트 비서야. 현황을 보고 한 줄 인사이트를 줘.
+
+## 현재 진행률
+- 전체: ${summary.total}개
+- 완료: ${summary.done}개 (${summary.progressPercent}%)
+- 진행중: ${summary.inProgress}개
+- 대기: ${summary.todo}개
+- 차단: ${summary.blocked}개
+
+## 태스크 목록
+${formatTaskList(context)}
+
+## 최근 결정 사항
+${formatDecisions(context)}
+
+## 요청
+한 줄로 현재 상황에 대한 인사이트를 줘. "💡 " 로 시작해. 한국어로 답변해.`;
+}
+
+export function buildNextPrompt(context: AdvisorContext): string {
+  return `너는 프로젝트 비서야. 다음에 할 태스크를 추천해.
+
+## 전체 태스크 목록
+${formatTaskList(context)}
+
+## 최근 결정 사항
+${formatDecisions(context)}
+
+${context.trdContent ? `## TRD (구현 계획)\n${context.trdContent}\n` : ""}
+${context.prdContent ? `## PRD (제품 요구사항)\n${context.prdContent}\n` : ""}
+
+## 요청
+다음에 할 태스크 1개를 추천해. 아래 형식으로 답변해:
+
+👉 추천: #ID 태스크 제목
+   이유: (왜 이것을 다음에 해야 하는지)
+   의존: (선행 태스크가 있다면)
+
+한국어로 답변해. 짧게.`;
+}
+
+export function buildAskPrompt(context: AdvisorContext, question: string): string {
+  return `너는 프로젝트 비서야. 질문에 맞게 답변해.
+짧은 질문이면 짧게, 현황 질문이면 브리핑 형태로.
+
+## 태스크 목록
+${formatTaskList(context)}
+
+## 최근 결정 사항
+${formatDecisions(context)}
+
+${context.trdContent ? `## TRD\n${context.trdContent}\n` : ""}
+${context.prdContent ? `## PRD\n${context.prdContent}\n` : ""}
+${context.gitDiff ? `## 최근 코드 변경\n${context.gitDiff}\n` : ""}
+${context.conversationLogs ? `## 관련 대화 로그\n${formatConvLogs(context)}\n` : ""}
+
+## 질문
+${question}
+
+한국어로 답변해.`;
+}
+
+function formatTaskList(context: AdvisorContext): string {
+  if (context.tasks.length === 0) return "(태스크 없음)";
+  return context.tasks
+    .map((t) => `- [${t.status}] #${t.id} ${t.title} (우선순위: ${t.priority}, 의존: ${t.dependencies.join(", ") || "없음"})`)
+    .join("\n");
+}
+
+function formatDecisions(context: AdvisorContext): string {
+  if (context.decisions.length === 0) return "(결정 기록 없음)";
+  return context.decisions
+    .map((d) => `- ${d.decision} (이유: ${d.reason})`)
+    .join("\n");
+}
+
+function formatConvLogs(context: AdvisorContext): string {
+  if (!context.conversationLogs || context.conversationLogs.length === 0) return "";
+  return context.conversationLogs
+    .map((l) => `[${l.role}] ${l.content}`)
+    .join("\n");
+}

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

@@ -0,0 +1,54 @@
+import type { Task, TaskFilter, TaskSortKey, TaskSortOrder, TaskStatus } from "../types";
+import { TASK_STATUSES } from "../types";
+
+export function filterTasks(tasks: Task[], filter: TaskFilter): Task[] {
+  return tasks.filter((task) => {
+    if (filter.status) {
+      const statuses: TaskStatus[] = Array.isArray(filter.status)
+        ? filter.status
+        : [filter.status];
+      if (!statuses.includes(task.status)) return false;
+    }
+
+    if (filter.priority !== undefined && task.priority !== filter.priority) {
+      return false;
+    }
+
+    if (filter.parentId !== undefined && task.parentId !== filter.parentId) {
+      return false;
+    }
+
+    if (filter.updatedSince && task.updatedAt < filter.updatedSince) {
+      return false;
+    }
+
+    if (filter.hasDependency && !task.dependencies.includes(filter.hasDependency)) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+export function sortTasks(
+  tasks: Task[],
+  key: TaskSortKey = "priority",
+  order: TaskSortOrder = "desc",
+): Task[] {
+  const sorted = [...tasks].sort((a, b) => {
+    if (key === "status") {
+      return TASK_STATUSES.indexOf(a.status) - TASK_STATUSES.indexOf(b.status);
+    }
+
+    const valA = a[key];
+    const valB = b[key];
+
+    if (typeof valA === "number" && typeof valB === "number") {
+      return valA - valB;
+    }
+
+    return String(valA).localeCompare(String(valB));
+  });
+
+  return order === "desc" ? sorted.reverse() : sorted;
+}

package/src/features/taskflow/lib/fs-utils.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+
+/**
+ * write-temp-rename 전략으로 원자적 파일 쓰기
+ * 임시파일에 먼저 쓴 후 rename하여 손상 방지
+ */
+export async function atomicWrite(filePath: string, content: string): Promise<void> {
+  const dir = path.dirname(filePath);
+  const tmpPath = path.join(dir, `.${path.basename(filePath)}.${crypto.randomUUID()}.tmp`);
+
+  await fs.writeFile(tmpPath, normalizeLineEndings(content), "utf-8");
+  await fs.rename(tmpPath, filePath);
+}
+
+export function normalizeLineEndings(content: string): string {
+  return content.replace(/\r\n/g, "\n");
+}
+
+export async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function safeReadFile(filePath: string): Promise<string | null> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return normalizeLineEndings(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function safeRemove(filePath: string): Promise<boolean> {
+  try {
+    await fs.unlink(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,148 @@
+import type { Task } from "../types";
+
+// ── Cycle Detection (DFS) ──
+
+export function detectCycles(tasks: Task[]): string[][] {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const visited = new Set<string>();
+  const inStack = new Set<string>();
+  const cycles: string[][] = [];
+
+  function dfs(id: string, path: string[]): void {
+    if (inStack.has(id)) {
+      const start = path.indexOf(id);
+      cycles.push(path.slice(start).concat(id));
+      return;
+    }
+    if (visited.has(id)) return;
+
+    visited.add(id);
+    inStack.add(id);
+
+    const task = taskMap.get(id);
+    if (task) {
+      for (const dep of task.dependencies) {
+        if (taskMap.has(dep)) {
+          dfs(dep, [...path, id]);
+        }
+      }
+    }
+
+    inStack.delete(id);
+  }
+
+  for (const task of tasks) {
+    if (!visited.has(task.id)) {
+      dfs(task.id, []);
+    }
+  }
+
+  return cycles;
+}
+
+// ── Ready Set (all deps Done) ──
+
+export interface ReadyResult {
+  ready: Task[];
+  blocked: BlockedTask[];
+}
+
+export interface BlockedTask {
+  task: Task;
+  pendingDeps: string[];
+}
+
+export function computeReadySet(tasks: Task[]): ReadyResult {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const ready: Task[] = [];
+  const blocked: BlockedTask[] = [];
+
+  for (const task of tasks) {
+    if (task.status === "Done") continue;
+
+    const pendingDeps = task.dependencies.filter((depId) => {
+      const dep = taskMap.get(depId);
+      return dep && dep.status !== "Done";
+    });
+
+    if (pendingDeps.length === 0) {
+      ready.push(task);
+    } else {
+      blocked.push({ task, pendingDeps });
+    }
+  }
+
+  return { ready, blocked };
+}
+
+// ── Scoring ──
+
+const WEIGHTS = {
+  priority: 10,
+  recency: 3,
+  inProgress: 5,
+  blockedPenalty: -20,
+};
+
+const DAY_MS = 86_400_000;
+
+export function scoreTask(task: Task): number {
+  let score = 0;
+
+  // Priority contribution (0-10 → 0-100)
+  score += task.priority * WEIGHTS.priority;
+
+  // Recency bonus (more recent update = higher score)
+  const daysSinceUpdate = (Date.now() - new Date(task.updatedAt).getTime()) / DAY_MS;
+  score += Math.max(0, WEIGHTS.recency * (30 - daysSinceUpdate));
+
+  // In-progress bonus
+  if (task.status === "InProgress") {
+    score += WEIGHTS.inProgress;
+  }
+
+  // Blocked penalty
+  if (task.status === "Blocked") {
+    score += WEIGHTS.blockedPenalty;
+  }
+
+  return score;
+}
+
+// ── Recommendation ──
+
+export interface RecommendOptions {
+  limit?: number;
+  includeBlocked?: boolean;
+  all?: boolean;
+}
+
+export interface Recommendation {
+  task: Task;
+  score: number;
+  pendingDeps?: string[];
+}
+
+export function recommend(tasks: Task[], options: RecommendOptions = {}): Recommendation[] {
+  const limit = options.all ? Infinity : (options.limit ?? 5);
+  const { ready, blocked } = computeReadySet(tasks);
+
+  const recommendations: Recommendation[] = ready.map((task) => ({
+    task,
+    score: scoreTask(task),
+  }));
+
+  if (options.includeBlocked) {
+    for (const { task, pendingDeps } of blocked) {
+      recommendations.push({
+        task,
+        score: scoreTask(task),
+        pendingDeps,
+      });
+    }
+  }
+
+  return recommendations
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+}

package/src/features/taskflow/lib/index-builder.ts

@@ -0,0 +1,42 @@
+import { getIndexFilePath } from "../constants";
+import type { Task } from "../types";
+import { atomicWrite, ensureDir } from "./fs-utils";
+import path from "node:path";
+
+function formatDate(iso: string): string {
+  return iso.slice(0, 10);
+}
+
+function buildMarkdownTable(tasks: Task[]): string {
+  const lines: string[] = [
+    "# TaskFlow Index",
+    "",
+    `> Auto-generated at ${new Date().toISOString()}`,
+    "",
+    "| ID | Title | Status | Priority | Dependencies | Updated |",
+    "|----|-------|--------|----------|--------------|---------|",
+  ];
+
+  const sorted = [...tasks].sort((a, b) => b.priority - a.priority);
+
+  for (const task of sorted) {
+    const deps = task.dependencies.length > 0 ? task.dependencies.join(", ") : "-";
+    lines.push(
+      `| ${task.id} | ${task.title} | ${task.status} | ${task.priority} | ${deps} | ${formatDate(task.updatedAt)} |`,
+    );
+  }
+
+  lines.push("");
+  lines.push(`Total: ${tasks.length} tasks`);
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+export async function rebuildIndex(projectRoot: string, tasks: Task[]): Promise<void> {
+  const indexPath = getIndexFilePath(projectRoot);
+  await ensureDir(path.dirname(indexPath));
+
+  const content = buildMarkdownTable(tasks);
+  await atomicWrite(indexPath, content);
+}