@kmgeon/taskflow 0.1.3

package/src/core/claude-runner/spawner.ts

@@ -0,0 +1,86 @@
+import { spawnSync, spawn } from "child_process";
+
+export interface SpawnResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+/**
+ * Claude CLI를 실행한다.
+ *
+ * - spawnSync + stdio: 'inherit'로 실시간 터미널 I/O
+ * - dry-run 모드: CC_DRY_RUN=1이면 실제 spawn 없이 명령어 출력
+ * - env 파라미터: process.env에 merge되어 subprocess에 전달
+ */
+export function spawnClaude(
+  flags: string[],
+  env?: Record<string, string>,
+): SpawnResult {
+  if (process.env.CC_DRY_RUN === "1") {
+    const command = ["claude", ...flags].join(" ");
+    process.stdout.write(`[DRY-RUN] ${command}\n`);
+    if (env && Object.keys(env).length > 0) {
+      process.stdout.write(`[DRY-RUN] env: ${Object.keys(env).join(", ")}\n`);
+    }
+    return { exitCode: 0, stdout: "", stderr: "" };
+  }
+
+  const result = spawnSync("claude", flags, {
+    stdio: "inherit",
+    env: { ...process.env, ...env },
+  });
+
+  return {
+    exitCode: result.status ?? 1,
+    stdout: "",
+    stderr: "",
+  };
+}
+
+/**
+ * Claude CLI를 실행하되, stdout을 캡처하면서 터미널에도 출력한다.
+ *
+ * - stdin/stderr는 터미널에 직접 연결 (대화형 유지)
+ * - stdout은 pipe → 터미널 출력 + 버퍼 저장
+ */
+export interface SpawnCaptureOptions {
+  env?: Record<string, string>;
+  /** stdout 청크를 터미널에 쓰기 전에 변환하는 함수 */
+  transformOutput?: (text: string) => string;
+}
+
+export function spawnClaudeWithCapture(
+  flags: string[],
+  options?: SpawnCaptureOptions,
+): Promise<SpawnResult> {
+  const { env, transformOutput } = options ?? {};
+  if (process.env.CC_DRY_RUN === "1") {
+    const command = ["claude", ...flags].join(" ");
+    process.stdout.write(`[DRY-RUN] ${command}\n`);
+    return Promise.resolve({ exitCode: 0, stdout: "", stderr: "" });
+  }
+
+  return new Promise((resolve) => {
+    const child = spawn("claude", flags, {
+      stdio: ["inherit", "pipe", "inherit"],
+      env: { ...process.env, ...env },
+    });
+
+    const chunks: Buffer[] = [];
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      const text = chunk.toString("utf-8");
+      process.stdout.write(transformOutput ? transformOutput(text) : text);
+      chunks.push(chunk);
+    });
+
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout: Buffer.concat(chunks).toString("utf-8"),
+        stderr: "",
+      });
+    });
+  });
+}

package/src/core/prd/__tests__/auto-analyzer.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { maskSensitive, extractSignature, inferProjectName } from "../auto-analyzer.js";
+import type { FileSample } from "../auto-analyzer.js";
+
+describe("maskSensitive", () => {
+  it("should mask API keys", () => {
+    const input = 'const apiKey = "sk-abc123def456ghi789jkl012"';
+    const result = maskSensitive(input);
+    expect(result).not.toContain("sk-abc123def456ghi789jkl012");
+    expect(result).toContain("[REDACTED]");
+  });
+});
+
+describe("extractSignature", () => {
+  it("should keep import/export lines within byte limit", () => {
+    const content = 'import foo from "bar";\nexport function test() {}\nconst x = 1;\nconst y = 2;\n';
+    const result = extractSignature(content, 100);
+    expect(result).toContain("import foo");
+    expect(result).toContain("export function");
+  });
+});
+
+describe("inferProjectName", () => {
+  it("should extract name from package.json sample", () => {
+    const samples: FileSample[] = [
+      { path: "package.json", content: '{"name": "my-project"}', truncated: false },
+    ];
+    expect(inferProjectName(samples, "/tmp/test")).toBe("my-project");
+  });
+
+  it("should fallback to projectRoot basename", () => {
+    const samples: FileSample[] = [];
+    expect(inferProjectName(samples, "/tmp/my-awesome-project")).toBe("my-awesome-project");
+  });
+});

package/src/core/prd/__tests__/generator.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { savePrd } from "../generator.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+describe("savePrd", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gen-test-"));
+    await fs.mkdir(path.join(tmpDir, ".taskflow"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should save PRD markdown to .taskflow/prd.md", async () => {
+    const markdown = "# Test PRD\n\nContent here";
+    const result = await savePrd(tmpDir, markdown);
+    expect(result).toContain("prd.md");
+    const content = await fs.readFile(result, "utf-8");
+    expect(content).toBe(markdown);
+  });
+});

package/src/core/prd/__tests__/scanner.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { maskSensitive, extractSignature, inferProjectName } from "../scanner.js";
+import type { FileSample } from "../scanner.js";
+
+describe("maskSensitive", () => {
+  it("should mask API keys", () => {
+    const input = 'const apiKey = "sk-abc123def456ghi789jkl012"';
+    const result = maskSensitive(input);
+    expect(result).not.toContain("sk-abc123def456ghi789jkl012");
+    expect(result).toContain("[REDACTED]");
+  });
+});
+
+describe("extractSignature", () => {
+  it("should keep import/export lines within byte limit", () => {
+    const content = 'import foo from "bar";\nexport function test() {}\nconst x = 1;\nconst y = 2;\n';
+    const result = extractSignature(content, 100);
+    expect(result).toContain("import foo");
+    expect(result).toContain("export function");
+  });
+});
+
+describe("inferProjectName", () => {
+  it("should extract name from package.json sample", () => {
+    const samples: FileSample[] = [
+      { path: "package.json", content: '{"name": "my-project"}', truncated: false },
+    ];
+    expect(inferProjectName(samples, "/tmp/test")).toBe("my-project");
+  });
+
+  it("should fallback to projectRoot basename", () => {
+    const samples: FileSample[] = [];
+    expect(inferProjectName(samples, "/tmp/my-awesome-project")).toBe("my-awesome-project");
+  });
+});

package/src/core/prd/auto-analyzer.ts

@@ -0,0 +1,9 @@
+// 하위 호환성을 위한 re-export
+export {
+  type FileSample,
+  maskSensitive,
+  extractSignature,
+  scanFiles,
+  sampleFiles,
+  inferProjectName,
+} from "./scanner.js";

package/src/core/prd/generator.ts

@@ -0,0 +1,8 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export async function savePrd(projectRoot: string, markdown: string): Promise<string> {
+  const filePath = path.join(projectRoot, ".taskflow", "prd.md");
+  await fs.writeFile(filePath, markdown, "utf-8");
+  return filePath;
+}

package/src/core/prd/scanner.ts

@@ -0,0 +1,117 @@
+import fg from "fast-glob";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+
+const SCAN_PATTERNS = [
+  "package.json", "tsconfig*.json", "next.config.*", "vite.config.*",
+  "nuxt.config.*", "nest-cli.json", "angular.json",
+  "docker-compose*.{yml,yaml}", "Dockerfile", ".env.example",
+  "src/**/*.{ts,tsx,js,jsx}", "app/**/*.{ts,tsx,js,jsx}",
+  "server/**/*.{ts,tsx,js,jsx}", "api/**/*.{ts,tsx,js,jsx}",
+  "lib/**/*.{ts,tsx,js,jsx}", "pages/**/*.{ts,tsx,js,jsx}",
+];
+
+const IGNORE_PATTERNS = [
+  "**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**",
+  "**/.next/**", "**/coverage/**", "**/*.test.*", "**/*.spec.*",
+  "**/__tests__/**", "**/*.d.ts",
+];
+
+export const MAX_BYTES_PER_FILE = 16_000;
+export const MAX_FILES = 200;
+
+const SENSITIVE_PATTERNS = [
+  /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]\s*["']?[^\s"',]+/gi,
+  /(?:sk|pk|key)-[a-zA-Z0-9]{20,}/g,
+  /\/Users\/[^\s/]+/g,
+  /\/home\/[^\s/]+/g,
+  /C:\\Users\\[^\s\\]+/g,
+];
+
+export function maskSensitive(content: string): string {
+  let masked = content;
+  for (const pattern of SENSITIVE_PATTERNS) {
+    masked = masked.replace(pattern, "[REDACTED]");
+  }
+  return masked;
+}
+
+export interface FileSample {
+  path: string;
+  content: string;
+  truncated: boolean;
+}
+
+export async function scanFiles(cwd: string): Promise<string[]> {
+  const files = await fg(SCAN_PATTERNS, {
+    cwd,
+    ignore: IGNORE_PATTERNS,
+    dot: true,
+    absolute: false,
+    onlyFiles: true,
+  });
+  return files.slice(0, MAX_FILES).sort();
+}
+
+export function extractSignature(content: string, maxBytes: number): string {
+  if (Buffer.byteLength(content, "utf-8") <= maxBytes) {
+    return content;
+  }
+
+  const lines = content.split("\n");
+  const significant: string[] = [];
+  let bytes = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const isSignificant =
+      trimmed.startsWith("import ") || trimmed.startsWith("export ") ||
+      trimmed.startsWith("//") || trimmed.startsWith("/*") ||
+      trimmed.startsWith("* ") || trimmed.startsWith("*/") ||
+      trimmed.startsWith("interface ") || trimmed.startsWith("type ") ||
+      trimmed.startsWith("class ") || trimmed.startsWith("function ") ||
+      trimmed.startsWith("const ") || trimmed.startsWith("async function") ||
+      trimmed.startsWith("@") ||
+      /^\s*(app|router|server)\.(get|post|put|delete|patch|use)\(/.test(trimmed) ||
+      trimmed === "" || trimmed === "{" || trimmed === "}";
+
+    if (isSignificant) {
+      const lineBytes = Buffer.byteLength(line + "\n", "utf-8");
+      if (bytes + lineBytes > maxBytes) break;
+      significant.push(line);
+      bytes += lineBytes;
+    }
+  }
+
+  return significant.join("\n");
+}
+
+export async function sampleFiles(filePaths: string[], cwd: string): Promise<FileSample[]> {
+  const samples: FileSample[] = [];
+
+  for (const filePath of filePaths) {
+    try {
+      const fullPath = `${cwd}/${filePath}`;
+      const raw = await readFile(fullPath, "utf-8");
+      const originalBytes = Buffer.byteLength(raw, "utf-8");
+      const content = extractSignature(raw, MAX_BYTES_PER_FILE);
+      const masked = maskSensitive(content);
+      samples.push({ path: filePath, content: masked, truncated: originalBytes > MAX_BYTES_PER_FILE });
+    } catch {
+      // skip unreadable files
+    }
+  }
+
+  return samples;
+}
+
+export function inferProjectName(samples: FileSample[], projectRoot: string): string {
+  const pkgSample = samples.find((s) => s.path === "package.json");
+  if (pkgSample) {
+    try {
+      const pkg = JSON.parse(pkgSample.content);
+      if (pkg.name && typeof pkg.name === "string") return pkg.name;
+    } catch { /* fallback */ }
+  }
+  return basename(projectRoot);
+}

package/src/core/project/__tests__/claude-setup.test.ts

@@ -0,0 +1,133 @@
+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 {
+  generateClaudeMd,
+  generateMcpJson,
+  appendClaudeImport,
+} from "../claude-setup.js";
+
+describe("generateClaudeMd", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "claude-setup-"));
+    await fs.mkdir(path.join(tmpDir, ".taskflow"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should generate .taskflow/CLAUDE.md with project info", async () => {
+    await generateClaudeMd(tmpDir, {
+      projectName: "TestProject",
+      summary: "A test project",
+      stack: ["TypeScript", "Next.js"],
+    });
+
+    const content = await fs.readFile(path.join(tmpDir, ".taskflow/CLAUDE.md"), "utf-8");
+    expect(content).toContain("TestProject");
+    expect(content).toContain("A test project");
+    expect(content).toContain("TypeScript");
+    expect(content).toContain("list_tasks");
+    // new MCP tools
+    expect(content).toContain("scan_codebase");
+    expect(content).toContain("save_prd");
+    expect(content).toContain("read_prd");
+    // old tools should not be present
+    expect(content).not.toContain("brainstorm_prd");
+    expect(content).not.toContain("auto_analyze_prd");
+    expect(content).not.toContain("parse_prd");
+    expect(content).not.toContain("brainstorm_task");
+    expect(content).not.toContain("refine_tasks");
+    expect(content).not.toContain("generate_feature_prd");
+    // skill commands
+    expect(content).toContain("/prd");
+    expect(content).toContain("/trd");
+    expect(content).toContain("/brainstorm");
+    expect(content).toContain("/refine");
+    expect(content).toContain("/parse-prd");
+    expect(content).toContain("/next");
+    expect(content).toContain("/task-status");
+  });
+});
+
+describe("generateMcpJson", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "mcp-json-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should create .mcp.json with taskflow server config", async () => {
+    await generateMcpJson(tmpDir);
+
+    const content = await fs.readFile(path.join(tmpDir, ".mcp.json"), "utf-8");
+    const parsed = JSON.parse(content);
+    expect(parsed.mcpServers.taskflow).toBeDefined();
+    expect(parsed.mcpServers.taskflow.type).toBe("stdio");
+  });
+
+  it("should merge with existing .mcp.json without overwriting other servers", async () => {
+    await fs.writeFile(
+      path.join(tmpDir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { other: { type: "stdio", command: "other" } } }),
+    );
+
+    await generateMcpJson(tmpDir);
+
+    const content = await fs.readFile(path.join(tmpDir, ".mcp.json"), "utf-8");
+    const parsed = JSON.parse(content);
+    expect(parsed.mcpServers.other).toBeDefined();
+    expect(parsed.mcpServers.taskflow).toBeDefined();
+  });
+});
+
+describe("appendClaudeImport", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "claude-import-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should create CLAUDE.md with import if it does not exist", async () => {
+    await appendClaudeImport(tmpDir);
+
+    const content = await fs.readFile(path.join(tmpDir, "CLAUDE.md"), "utf-8");
+    expect(content).toContain("@./.taskflow/CLAUDE.md");
+  });
+
+  it("should append import to existing CLAUDE.md", async () => {
+    await fs.writeFile(path.join(tmpDir, "CLAUDE.md"), "# My Project\n\nExisting content\n");
+
+    await appendClaudeImport(tmpDir);
+
+    const content = await fs.readFile(path.join(tmpDir, "CLAUDE.md"), "utf-8");
+    expect(content).toContain("# My Project");
+    expect(content).toContain("Existing content");
+    expect(content).toContain("@./.taskflow/CLAUDE.md");
+  });
+
+  it("should not duplicate import if already present", async () => {
+    await fs.writeFile(
+      path.join(tmpDir, "CLAUDE.md"),
+      "# My Project\n\n## TaskFlow\n@./.taskflow/CLAUDE.md\n",
+    );
+
+    await appendClaudeImport(tmpDir);
+
+    const content = await fs.readFile(path.join(tmpDir, "CLAUDE.md"), "utf-8");
+    const matches = content.match(/@\.\/\.taskflow\/CLAUDE\.md/g);
+    expect(matches).toHaveLength(1);
+  });
+});

package/src/core/project/__tests__/config.test.ts

@@ -0,0 +1,30 @@
+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 { readConfig, writeConfig, DEFAULT_CONFIG } from "../config.js";
+
+describe("config", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "taskflow-test-"));
+    await fs.mkdir(path.join(tmpDir, ".taskflow"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should return default config when file does not exist", async () => {
+    const config = await readConfig(tmpDir);
+    expect(config).toEqual(DEFAULT_CONFIG);
+  });
+
+  it("should write and read config", async () => {
+    const config = { ...DEFAULT_CONFIG, project: { ...DEFAULT_CONFIG.project, name: "test" } };
+    await writeConfig(tmpDir, config);
+    const result = await readConfig(tmpDir);
+    expect(result.project.name).toBe("test");
+  });
+});

package/src/core/project/__tests__/init.test.ts

@@ -0,0 +1,37 @@
+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 { initProject } from "../init.js";
+
+describe("initProject", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "taskflow-init-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should create .taskflow directory and config.json", async () => {
+    const result = await initProject(tmpDir);
+    expect(result.created).toBe(true);
+
+    const stat = await fs.stat(path.join(tmpDir, ".taskflow"));
+    expect(stat.isDirectory()).toBe(true);
+
+    const config = await fs.readFile(path.join(tmpDir, ".taskflow/config.json"), "utf-8");
+    expect(JSON.parse(config).version).toBe("1.0");
+  });
+
+  it("should return created=false when .taskflow already exists", async () => {
+    await fs.mkdir(path.join(tmpDir, ".taskflow"), { recursive: true });
+    await fs.writeFile(path.join(tmpDir, ".taskflow/config.json"), "{}");
+
+    const result = await initProject(tmpDir);
+    expect(result.created).toBe(false);
+    expect(result.alreadyExists).toBe(true);
+  });
+});

package/src/core/project/__tests__/skill-setup.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { installSkills, SKILL_NAMES } from "../skill-setup.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+describe("installSkills", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "skill-test-"));
+    await fs.mkdir(path.join(tmpDir, ".taskflow"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should create skill source files and symlinks", async () => {
+    await installSkills(tmpDir);
+
+    const srcDir = path.join(tmpDir, ".taskflow", ".claude", "commands");
+    const destDir = path.join(tmpDir, ".claude", "commands");
+
+    for (const name of SKILL_NAMES) {
+      const srcFile = path.join(srcDir, `${name}.md`);
+      const srcContent = await fs.readFile(srcFile, "utf-8");
+      expect(srcContent.length).toBeGreaterThan(0);
+
+      const linkPath = path.join(destDir, `${name}.md`);
+      const stat = await fs.lstat(linkPath);
+      expect(stat.isSymbolicLink()).toBe(true);
+
+      const linkContent = await fs.readFile(linkPath, "utf-8");
+      expect(linkContent).toBe(srcContent);
+    }
+  });
+
+  it("should skip symlink if destination file already exists", async () => {
+    const destDir = path.join(tmpDir, ".claude", "commands");
+    await fs.mkdir(destDir, { recursive: true });
+    await fs.writeFile(path.join(destDir, "prd.md"), "# user custom prd");
+
+    await installSkills(tmpDir);
+
+    const content = await fs.readFile(path.join(destDir, "prd.md"), "utf-8");
+    expect(content).toBe("# user custom prd");
+  });
+
+  it("should overwrite stale skill source files on re-init", async () => {
+    await installSkills(tmpDir);
+
+    const srcFile = path.join(tmpDir, ".taskflow", ".claude", "commands", "prd.md");
+    await fs.writeFile(srcFile, "# old content");
+
+    await installSkills(tmpDir);
+
+    const content = await fs.readFile(srcFile, "utf-8");
+    expect(content).not.toBe("# old content");
+    expect(content).toContain("PRD");
+  });
+});