@kmgeon/taskflow 0.1.3

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

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import { parseTask, serializeTask } from "../serializer";
+import type { Task } from "../../types";
+
+const SAMPLE_TASK: Task = {
+  id: "001",
+  title: "Setup project",
+  status: "Todo",
+  priority: 3,
+  dependencies: [],
+  createdAt: "2026-03-21T00:00:00.000Z",
+  updatedAt: "2026-03-21T00:00:00.000Z",
+  description: "Initialize the project structure.",
+};
+
+const SAMPLE_MD = `---
+id: "001"
+title: Setup project
+status: Todo
+priority: 3
+createdAt: "2026-03-21T00:00:00.000Z"
+updatedAt: "2026-03-21T00:00:00.000Z"
+---
+Initialize the project structure.
+`;
+
+describe("serializeTask", () => {
+  it("should produce valid frontmatter markdown", () => {
+    const output = serializeTask(SAMPLE_TASK);
+
+    expect(output).toContain("id:");
+    expect(output).toContain("001");
+    expect(output).toContain("title: Setup project");
+    expect(output).toContain("status: Todo");
+    expect(output).toContain("priority: 3");
+    expect(output).toContain("Initialize the project structure.");
+  });
+
+  it("should include dependencies when present", () => {
+    const task = { ...SAMPLE_TASK, dependencies: ["002", "003"] };
+    const output = serializeTask(task);
+
+    expect(output).toContain("dependencies:");
+    expect(output).toContain("002");
+    expect(output).toContain("003");
+  });
+
+  it("should omit dependencies when empty", () => {
+    const output = serializeTask(SAMPLE_TASK);
+    expect(output).not.toContain("dependencies:");
+  });
+
+  it("should include parentId when present", () => {
+    const task = { ...SAMPLE_TASK, parentId: "000" };
+    const output = serializeTask(task);
+    expect(output).toContain("parentId:");
+    expect(output).toContain("000");
+  });
+});
+
+describe("parseTask", () => {
+  it("should parse frontmatter and body", () => {
+    const task = parseTask(SAMPLE_MD);
+
+    expect(task.id).toBe("001");
+    expect(task.title).toBe("Setup project");
+    expect(task.status).toBe("Todo");
+    expect(task.priority).toBe(3);
+    expect(task.description).toBe("Initialize the project structure.");
+  });
+
+  it("should default status to Todo for invalid values", () => {
+    const md = SAMPLE_MD.replace("status: Todo", "status: InvalidStatus");
+    const task = parseTask(md);
+    expect(task.status).toBe("Todo");
+  });
+
+  it("should default empty dependencies", () => {
+    const task = parseTask(SAMPLE_MD);
+    expect(task.dependencies).toEqual([]);
+  });
+
+  it("should throw for missing required fields", () => {
+    const md = `---\ntitle: Test\n---\nBody`;
+    expect(() => parseTask(md)).toThrow("missing required fields");
+  });
+
+  it("should roundtrip serialize/parse", () => {
+    const serialized = serializeTask(SAMPLE_TASK);
+    const parsed = parseTask(serialized);
+
+    expect(parsed.id).toBe(SAMPLE_TASK.id);
+    expect(parsed.title).toBe(SAMPLE_TASK.title);
+    expect(parsed.status).toBe(SAMPLE_TASK.status);
+    expect(parsed.priority).toBe(SAMPLE_TASK.priority);
+    expect(parsed.description).toBe(SAMPLE_TASK.description);
+  });
+});

package/src/features/taskflow/lib/advisor/__tests__/advisor-integration.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { AdvisorDb } from "../db.js";
+import { buildLocalSummary, formatStatusOutput } from "../local-summary.js";
+import { buildContext, classifyQuestion } from "../context-builder.js";
+import { createTask, ensureRepo, listTasks } from "../../repository.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "advisor-integ-"));
+  await ensureRepo(tmpDir);
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("Advisor Integration", () => {
+  it("should build local summary from real tasks", async () => {
+    await createTask(tmpDir, { title: "Task 1", status: "Done" });
+    await createTask(tmpDir, { title: "Task 2", status: "Todo" });
+    await createTask(tmpDir, { title: "Task 3", status: "InProgress" });
+
+    const tasks = await listTasks(tmpDir);
+    const summary = buildLocalSummary(tasks);
+
+    expect(summary.total).toBe(3);
+    expect(summary.done).toBe(1);
+    expect(summary.progressPercent).toBe(33);
+  });
+
+  it("should build context with DB decisions", async () => {
+    await createTask(tmpDir, { title: "Test Task" });
+
+    const dbPath = path.join(tmpDir, ".taskflow", "advisor.db");
+    const db = await AdvisorDb.open(dbPath);
+    db.insertDecision("s1", "Test decision", "Test reason", ["1"]);
+
+    const context = await buildContext({
+      command: "status",
+      projectRoot: tmpDir,
+      db,
+    });
+
+    expect(context.tasks.length).toBe(1);
+    expect(context.decisions.length).toBe(1);
+    expect(context.decisions[0].decision).toBe("Test decision");
+
+    db.close();
+  });
+
+  it("should persist DB, reload, and retain data", async () => {
+    const dbPath = path.join(tmpDir, ".taskflow", "advisor.db");
+
+    const db1 = await AdvisorDb.open(dbPath);
+    db1.insertLog("ask", "s1", "user", "테스트 질문");
+    db1.insertDecision("s1", "테스트 결정", "이유", []);
+    await db1.persistToDisk();
+    db1.close();
+
+    const db2 = await AdvisorDb.open(dbPath);
+    expect(db2.getLogsBySession("s1")).toHaveLength(1);
+    expect(db2.getAllDecisions()).toHaveLength(1);
+    db2.close();
+  });
+
+  it("should format status output correctly", async () => {
+    await createTask(tmpDir, { title: "Done task", status: "Done" });
+    await createTask(tmpDir, { title: "Todo task", status: "Todo" });
+
+    const tasks = await listTasks(tmpDir);
+    const summary = buildLocalSummary(tasks);
+    const output = formatStatusOutput(summary);
+
+    expect(output).toContain("1/2");
+    expect(output).toContain("50%");
+  });
+
+  it("should classify questions correctly in context building", async () => {
+    await createTask(tmpDir, { title: "Test" });
+    const dbPath = path.join(tmpDir, ".taskflow", "advisor.db");
+    const db = await AdvisorDb.open(dbPath);
+
+    const ctx = await buildContext({
+      command: "ask",
+      projectRoot: tmpDir,
+      db,
+      question: "최근 코드 변경 뭐 있어?",
+    });
+
+    expect(ctx.tasks.length).toBe(1);
+
+    db.close();
+  });
+});

package/src/features/taskflow/lib/advisor/ai-advisor.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { getInsight, getRecommendation, getAnswer } from "./ai-advisor.js";
+import type { AdvisorContext } from "../../types.js";
+import type { LocalSummary } from "./local-summary.js";
+
+const mockContext: AdvisorContext = {
+  tasks: [
+    { id: "1", title: "Task A", status: "Done", priority: 5, dependencies: [] },
+    { id: "2", title: "Task B", status: "Todo", priority: 3, dependencies: ["1"] },
+  ],
+  decisions: [],
+};
+
+const mockSummary: LocalSummary = {
+  total: 2,
+  done: 1,
+  inProgress: 0,
+  todo: 1,
+  blocked: 0,
+  progressPercent: 50,
+  groups: { Done: [], InProgress: [], Todo: [], Blocked: [] },
+};
+
+describe("getInsight", () => {
+  it("should throw when AI client is unavailable", async () => {
+    await expect(getInsight(mockContext, mockSummary)).rejects.toThrow();
+  });
+});
+
+describe("getRecommendation", () => {
+  it("should throw when AI client is unavailable", async () => {
+    await expect(getRecommendation(mockContext)).rejects.toThrow();
+  });
+});
+
+describe("getAnswer", () => {
+  it("should throw when AI client is unavailable", async () => {
+    await expect(getAnswer(mockContext, "다음 뭐 해?")).rejects.toThrow();
+  });
+});

package/src/features/taskflow/lib/advisor/ai-advisor.ts

@@ -0,0 +1,20 @@
+import type { AdvisorContext } from "../../types.js";
+import type { LocalSummary } from "./local-summary.js";
+
+export async function getInsight(
+  _context: AdvisorContext,
+  _summary: LocalSummary
+): Promise<string> {
+  throw new Error("AI 인사이트 기능은 Claude Code 스킬을 통해 제공됩니다.");
+}
+
+export async function getRecommendation(_context: AdvisorContext): Promise<string> {
+  throw new Error("AI 추천 기능은 Claude Code 스킬을 통해 제공됩니다.");
+}
+
+export async function getAnswer(
+  _context: AdvisorContext,
+  _question: string
+): Promise<string> {
+  throw new Error("AI 답변 기능은 Claude Code 스킬을 통해 제공됩니다.");
+}

package/src/features/taskflow/lib/advisor/context-builder.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { classifyQuestion, buildContext, estimateTokens } from "./context-builder.js";
+import { AdvisorDb } from "./db.js";
+import { createTask, ensureRepo } from "../repository.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "ctx-builder-"));
+  await ensureRepo(tmpDir);
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("classifyQuestion", () => {
+  it("should detect code-related keywords", () => {
+    const result = classifyQuestion("최근 코드 변경사항 알려줘");
+    expect(result.needsGitDiff).toBe(true);
+  });
+
+  it("should detect decision-related keywords", () => {
+    const result = classifyQuestion("왜 인증을 빼기로 결정했어?");
+    expect(result.needsConversationLogs).toBe(true);
+  });
+
+  it("should detect planning keywords", () => {
+    const result = classifyQuestion("전체 목표가 뭐야?");
+    expect(result.needsTrdPrd).toBe(true);
+  });
+
+  it("should return defaults for generic questions", () => {
+    const result = classifyQuestion("다음 뭐 해?");
+    expect(result.needsGitDiff).toBe(false);
+    expect(result.needsConversationLogs).toBe(false);
+    expect(result.needsTrdPrd).toBe(false);
+  });
+});
+
+describe("buildContext", () => {
+  it("should always include tasks and decisions for status command", async () => {
+    await createTask(tmpDir, { title: "Test task" });
+    const db = await AdvisorDb.open(path.join(tmpDir, ".taskflow", "advisor.db"));
+    db.insertDecision("s1", "test decision", "reason", []);
+
+    const ctx = await buildContext({ command: "status", projectRoot: tmpDir, db });
+    expect(ctx.tasks.length).toBeGreaterThan(0);
+    expect(ctx.decisions.length).toBeGreaterThan(0);
+    expect(ctx.gitDiff).toBeUndefined();
+
+    db.close();
+  });
+
+  it("should include TRD/PRD for next command", async () => {
+    await createTask(tmpDir, { title: "Test task" });
+    const db = await AdvisorDb.open(path.join(tmpDir, ".taskflow", "advisor.db"));
+
+    const ctx = await buildContext({ command: "next", projectRoot: tmpDir, db });
+    expect(ctx.tasks.length).toBeGreaterThan(0);
+
+    db.close();
+  });
+});
+
+describe("estimateTokens", () => {
+  it("should approximate tokens from character count", () => {
+    expect(estimateTokens("hello world")).toBe(3); // 11 chars / 4 = 2.75 → 3
+  });
+});

package/src/features/taskflow/lib/advisor/context-builder.ts

@@ -0,0 +1,151 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { AdvisorContext, TaskSummary } from "../../types.js";
+import { listTasks } from "../repository.js";
+import type { AdvisorDb } from "./db.js";
+
+const TOKEN_BUDGET = {
+  status: 4_000,
+  next: 8_000,
+  ask: 12_000,
+} as const;
+
+const CODE_KEYWORDS = ["코드", "git", "커밋", "변경", "diff", "코드변경", "수정"];
+const DECISION_KEYWORDS = ["왜", "이유", "결정", "배경", "판단"];
+const PLANNING_KEYWORDS = ["계획", "전체", "목표", "방향", "prd", "trd"];
+
+export interface QuestionClassification {
+  needsGitDiff: boolean;
+  needsConversationLogs: boolean;
+  needsTrdPrd: boolean;
+}
+
+export function classifyQuestion(question: string): QuestionClassification {
+  const q = question.toLowerCase();
+  return {
+    needsGitDiff: CODE_KEYWORDS.some((kw) => q.includes(kw)),
+    needsConversationLogs: DECISION_KEYWORDS.some((kw) => q.includes(kw)),
+    needsTrdPrd: PLANNING_KEYWORDS.some((kw) => q.includes(kw)),
+  };
+}
+
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+interface BuildContextOptions {
+  command: "status" | "next" | "ask";
+  projectRoot: string;
+  db: AdvisorDb;
+  question?: string;
+}
+
+export async function buildContext(opts: BuildContextOptions): Promise<AdvisorContext> {
+  const { command, projectRoot, db, question } = opts;
+  const budget = TOKEN_BUDGET[command];
+
+  const tasks = await listTasks(projectRoot);
+  const taskSummaries: TaskSummary[] = tasks.map((t) => ({
+    id: t.id,
+    title: t.title,
+    status: t.status,
+    priority: t.priority,
+    dependencies: t.dependencies,
+  }));
+
+  const decisionLimit = command === "status" ? 10 : 20;
+  const decisions = db.getRecentDecisions(decisionLimit);
+
+  const context: AdvisorContext = { tasks: taskSummaries, decisions };
+
+  if (command === "status") return context;
+
+  if (command === "next") {
+    context.trdContent = await safeReadTrdPrd(projectRoot, "trd");
+    context.prdContent = await safeReadTrdPrd(projectRoot, "prd");
+    return truncateContext(context, budget);
+  }
+
+  if (command === "ask" && question) {
+    const classification = classifyQuestion(question);
+
+    if (classification.needsTrdPrd) {
+      context.trdContent = await safeReadTrdPrd(projectRoot, "trd");
+      context.prdContent = await safeReadTrdPrd(projectRoot, "prd");
+    }
+
+    if (classification.needsGitDiff) {
+      context.gitDiff = safeGitDiff(projectRoot);
+    }
+
+    if (classification.needsConversationLogs) {
+      context.conversationLogs = db.getLogsByType("brainstorm")
+        .concat(db.getLogsByType("refine"))
+        .concat(db.getLogsByType("prd"))
+        .slice(-50);
+    }
+
+    return truncateContext(context, budget);
+  }
+
+  return context;
+}
+
+async function safeReadTrdPrd(projectRoot: string, type: "trd" | "prd"): Promise<string | undefined> {
+  const candidates = [
+    path.join(projectRoot, "vooster-docs", `${type}.md`),
+    path.join(projectRoot, ".taskflow", `${type}.md`),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      return await fs.readFile(candidate, "utf-8");
+    } catch {
+      continue;
+    }
+  }
+
+  return undefined;
+}
+
+function safeGitDiff(projectRoot: string): string | undefined {
+  try {
+    const diff = execSync("git diff --stat HEAD~3", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 5_000,
+    });
+    return diff || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function truncateContext(context: AdvisorContext, maxTokens: number): AdvisorContext {
+  let totalTokens = estimateTokens(JSON.stringify(context));
+
+  if (totalTokens <= maxTokens) return context;
+
+  if (context.conversationLogs && totalTokens > maxTokens) {
+    context.conversationLogs = context.conversationLogs.slice(-20);
+    totalTokens = estimateTokens(JSON.stringify(context));
+  }
+
+  if (context.gitDiff && totalTokens > maxTokens) {
+    const lines = context.gitDiff.split("\n");
+    context.gitDiff = lines.slice(-5).join("\n");
+    totalTokens = estimateTokens(JSON.stringify(context));
+  }
+
+  if (context.trdContent && totalTokens > maxTokens) {
+    context.trdContent = context.trdContent.slice(0, 2000) + "\n...(truncated)";
+    totalTokens = estimateTokens(JSON.stringify(context));
+  }
+
+  if (context.prdContent && totalTokens > maxTokens) {
+    context.prdContent = context.prdContent.slice(0, 2000) + "\n...(truncated)";
+  }
+
+  return context;
+}

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

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { AdvisorDb } from "./db.js";
+
+let tmpDir: string;
+let db: AdvisorDb;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "advisor-db-"));
+  db = await AdvisorDb.open(path.join(tmpDir, "advisor.db"));
+});
+
+afterEach(async () => {
+  db.close();
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("AdvisorDb", () => {
+  describe("conversation_logs", () => {
+    it("should insert and query conversation logs", async () => {
+      db.insertLog("brainstorm", "session-1", "user", "hello");
+      db.insertLog("brainstorm", "session-1", "assistant", "hi there");
+
+      const logs = db.getLogsBySession("session-1");
+      expect(logs).toHaveLength(2);
+      expect(logs[0].role).toBe("user");
+      expect(logs[0].content).toBe("hello");
+      expect(logs[1].role).toBe("assistant");
+    });
+
+    it("should filter logs by session type", () => {
+      db.insertLog("brainstorm", "s1", "user", "msg1");
+      db.insertLog("ask", "s2", "user", "msg2");
+
+      const brainstormLogs = db.getLogsByType("brainstorm");
+      expect(brainstormLogs).toHaveLength(1);
+      expect(brainstormLogs[0].sessionId).toBe("s1");
+    });
+
+    it("should delete logs older than N days", () => {
+      db.insertLog("ask", "old", "user", "old message");
+      db.exec(
+        "UPDATE conversation_logs SET created_at = datetime('now', '-10 days') WHERE session_id = 'old'"
+      );
+      db.insertLog("ask", "new", "user", "new message");
+
+      const deleted = db.deleteExpiredLogs(7);
+      expect(deleted).toBe(1);
+
+      const remaining = db.getLogsByType("ask");
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0].sessionId).toBe("new");
+    });
+  });
+
+  describe("decisions", () => {
+    it("should insert and query decisions", () => {
+      db.insertDecision("session-1", "Use sql.js", "No native deps", ["1", "2"]);
+
+      const decisions = db.getAllDecisions();
+      expect(decisions).toHaveLength(1);
+      expect(decisions[0].decision).toBe("Use sql.js");
+      expect(decisions[0].relatedTasks).toEqual(["1", "2"]);
+    });
+
+    it("should get recent decisions with limit", () => {
+      db.insertDecision("s1", "Decision 1", "Reason 1", []);
+      db.insertDecision("s2", "Decision 2", "Reason 2", []);
+      db.insertDecision("s3", "Decision 3", "Reason 3", []);
+
+      const recent = db.getRecentDecisions(2);
+      expect(recent).toHaveLength(2);
+      expect(recent[0].decision).toBe("Decision 3");
+    });
+  });
+
+  describe("persistence", () => {
+    it("should persist to disk and reload", async () => {
+      const dbPath = path.join(tmpDir, "persist-test.db");
+      const db1 = await AdvisorDb.open(dbPath);
+      db1.insertDecision("s1", "Persisted decision", "reason", []);
+      await db1.persistToDisk();
+      db1.close();
+
+      const db2 = await AdvisorDb.open(dbPath);
+      const decisions = db2.getAllDecisions();
+      expect(decisions).toHaveLength(1);
+      expect(decisions[0].decision).toBe("Persisted decision");
+      db2.close();
+    });
+  });
+
+  describe("stats", () => {
+    it("should return correct stats", () => {
+      db.insertLog("ask", "s1", "user", "q1");
+      db.insertLog("ask", "s1", "assistant", "a1");
+      db.insertDecision("s1", "d1", "r1", []);
+
+      const stats = db.getStats();
+      expect(stats.logCount).toBe(2);
+      expect(stats.decisionCount).toBe(1);
+    });
+  });
+});