@goodtek/vibeops 0.2.0

package/dist/lib/task-summary.js

@@ -0,0 +1,276 @@
+/**
+ * Small text-extraction helpers used by `vibeops notion sync` and
+ * `vibeops task pull`.
+ *
+ * Everything here is read-only (`extract*`) or returns new strings the caller
+ * may write back (`upsertNotionPageSection`, `renderPulledTaskMarkdown`).
+ *
+ * Goal/Background extraction is deliberately heuristic:
+ *   - we strip markdown bullet/numbering prefixes,
+ *   - we collapse blank-line groups so the first non-empty paragraph wins,
+ *   - we truncate to `NOTION_TEXT_LIMIT` (default 1500 chars).
+ *
+ * We never include placeholder content such as `(not yet)`, legacy localized
+ * placeholders, or `(scaffolded ...)`; those become an empty string.
+ */
+import { readTextOrNull, writeText } from "./filesystem.js";
+import { isPlaceholderContent, readSection } from "./task.js";
+import { truncate } from "./notion-mappers.js";
+const PLACEHOLDER_RE = new RegExp(String.raw `^\(.*(not yet|fill in|unassigned|scaffold|\uBBF8\uC218\uD589|\uBBF8\uC815|\uCC44\uC6CC\uB77C).*\)$`, "i");
+function stripBullet(line) {
+    return line.replace(/^\s*(?:[-*+]|\d+\.)\s+/, "").trim();
+}
+function isHeading(line) {
+    return /^#{1,6}\s+/.test(line);
+}
+function compressBlank(lines) {
+    const out = [];
+    let blank = false;
+    for (const raw of lines) {
+        const line = raw.replace(/\s+$/u, "");
+        if (line.length === 0) {
+            if (!blank && out.length > 0)
+                out.push("");
+            blank = true;
+            continue;
+        }
+        blank = false;
+        out.push(line);
+    }
+    return out.join("\n").trim();
+}
+/**
+ * Pull a flattened, single-string summary from a `## Section`. Bullet points
+ * and numbered list items are joined with " · ". Placeholder bodies become "".
+ */
+export function summarizeSection(body, title, limit) {
+    const raw = readSection(body, title);
+    if (raw.length === 0)
+        return "";
+    if (isPlaceholderContent(raw))
+        return "";
+    const lines = raw.split("\n");
+    const cleaned = [];
+    for (const line of lines) {
+        const t = line.trim();
+        if (t.length === 0) {
+            cleaned.push("");
+            continue;
+        }
+        if (PLACEHOLDER_RE.test(t))
+            continue;
+        if (isHeading(t))
+            continue;
+        cleaned.push(stripBullet(t));
+    }
+    const compact = compressBlank(cleaned);
+    return truncate(compact, limit);
+}
+export function summarizeGoal(body, limit) {
+    const goal = summarizeSection(body, "Goal", limit);
+    if (goal.length > 0)
+        return goal;
+    return summarizeSection(body, "Background", limit);
+}
+export function summarizeResult(body, limit) {
+    return summarizeSection(body, "Result", limit);
+}
+/**
+ * Best-effort: pull the very first non-heading paragraph from an arbitrary
+ * markdown body (e.g. `docs/project/00-overview.md`). Returns "" if nothing
+ * useful is found.
+ */
+export function summarizeMarkdownLead(body, limit) {
+    const lines = body.split("\n");
+    const collected = [];
+    let started = false;
+    for (const raw of lines) {
+        const t = raw.trim();
+        if (t.length === 0) {
+            if (started)
+                break;
+            continue;
+        }
+        if (isHeading(t)) {
+            if (started)
+                break;
+            continue;
+        }
+        if (t.startsWith(">"))
+            continue;
+        started = true;
+        collected.push(stripBullet(t));
+    }
+    return truncate(collected.join(" ").trim(), limit);
+}
+/**
+ * Heuristic: scan `docs/project/05-current-state.md` (or any markdown) for an
+ * "MVP 1 ~ N" hint. Falls back to the first heading-derived MVP token.
+ */
+export function detectCurrentPhase(body) {
+    if (body.length === 0)
+        return "";
+    const m = body.match(/MVP\s*\d+(?:\s*[·•:\-]\s*[^\n]+)?/i);
+    if (m)
+        return m[0].trim().replace(/\s+/g, " ");
+    return "";
+}
+export function renderNotionPageBlock(inputs) {
+    return [
+        `- Page ID: \`${inputs.pageId}\``,
+        `- Docs Path: \`${inputs.docsRelativePath}\``,
+    ].join("\n");
+}
+const NOTION_PAGE_RE = /^-\s+Page ID:\s*`([^`]+)`/m;
+export function readNotionPageId(body) {
+    const section = readSection(body, "Notion Page");
+    if (section.length === 0)
+        return null;
+    const m = section.match(NOTION_PAGE_RE);
+    return m ? m[1].trim() : null;
+}
+/**
+ * Replace the body of an existing `## Notion Page` section, or append the
+ * section to the file if it doesn't exist yet. Returns the new file body
+ * (caller is responsible for writing it back).
+ */
+export function upsertNotionPageSection(body, inputs) {
+    const block = renderNotionPageBlock(inputs);
+    const HEADING_RE = /^(##+)\s+(.+?)\s*$/;
+    const lines = body.split("\n");
+    let startIdx = -1;
+    let endIdx = -1;
+    let level = 2;
+    for (let i = 0; i < lines.length; i++) {
+        const m = HEADING_RE.exec(lines[i]);
+        if (!m)
+            continue;
+        if (m[2].trim().toLowerCase() !== "notion page")
+            continue;
+        startIdx = i;
+        level = m[1].length;
+        let j = i + 1;
+        while (j < lines.length) {
+            const nm = HEADING_RE.exec(lines[j]);
+            if (nm && nm[1].length <= level)
+                break;
+            j++;
+        }
+        endIdx = j;
+        break;
+    }
+    if (startIdx < 0) {
+        const trimmed = body.replace(/\s+$/u, "");
+        return `${trimmed}\n\n## Notion Page\n\n${block}\n`;
+    }
+    const before = lines.slice(0, startIdx + 1);
+    const after = lines.slice(endIdx);
+    return [...before, "", block, "", ...after].join("\n").replace(/\n{3,}/g, "\n\n");
+}
+export async function writeNotionPageSection(filePath, inputs) {
+    const current = await readTextOrNull(filePath);
+    if (current === null)
+        return false;
+    const next = upsertNotionPageSection(current, inputs);
+    if (next === current)
+        return false;
+    await writeText(filePath, next);
+    return true;
+}
+/**
+ * Render the markdown body for a TASK file that `vibeops task pull` is
+ * creating from a Notion row. Always uses the 18-section skeleton so the
+ * downstream `vibeops task done` validation can still run.
+ *
+ * Only the fields Notion actually carries get prefilled; everything else
+ * stays a placeholder.
+ */
+export function renderPulledTaskMarkdown(inputs) {
+    const title = inputs.title.length > 0 ? inputs.title : "(pulled from Notion — fill in)";
+    const status = inputs.status.length > 0 ? inputs.status : "planned";
+    const phase = inputs.mvpPhase.length > 0 ? inputs.mvpPhase : "(unassigned)";
+    const summary = inputs.summary.length > 0 ? inputs.summary : "(Notion Summary is empty — fill in.)";
+    const notionBlock = renderNotionPageBlock({
+        pageId: inputs.pageId,
+        docsRelativePath: inputs.docsRelativePath,
+    });
+    return `# ${inputs.taskId} · ${title}
+
+> This file was generated by \`vibeops task pull\` from Notion metadata. The body is empty — the Builder/Planner Agent should fill it in.
+
+## Status
+
+${status}
+
+## MVP Phase
+
+${phase}
+
+## Goal
+
+${summary}
+
+## Background
+
+(pulled — fill in context beyond the Notion Summary.)
+
+## Scope
+
+- (pulled — Scope item 1)
+- (pulled — Scope item 2)
+
+## Out of Scope
+
+- (pulled)
+
+## Acceptance Criteria
+
+1. (pulled — verifiable statement 1)
+2. (pulled — verifiable statement 2)
+
+## Files to Inspect First
+
+- (pulled)
+
+## Expected Files to Change
+
+- new: (pulled)
+- update: (pulled)
+
+## Risks
+
+- (pulled)
+
+## Test Plan
+
+- (pulled)
+
+## Rollback Plan
+
+- (pulled)
+
+## Git Context
+
+(populated by \`vibeops task start ${inputs.taskId}\`)
+
+## Notion Page
+
+${notionBlock}
+
+## Implementation Plan
+
+1. (pulled)
+
+## Result
+
+(not yet)
+
+## Test Result
+
+(not yet)
+
+## Review Notes
+
+(not yet)
+`;
+}

package/dist/lib/task.js

@@ -0,0 +1,364 @@
+import { readdir } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import matter from "gray-matter";
+import { isDirectory, readText, writeText } from "./filesystem.js";
+const KNOWN_STATUSES = new Set([
+    "planned",
+    "in_progress",
+    "review",
+    "blocked",
+    "done",
+]);
+export function normalizeStatus(value) {
+    if (typeof value === "string") {
+        const s = value.toLowerCase().replace(/\s+/g, "_");
+        if (KNOWN_STATUSES.has(s))
+            return s;
+    }
+    return "planned";
+}
+export function statusDisplay(status) {
+    switch (status) {
+        case "planned":
+            return "Planned";
+        case "in_progress":
+            return "In Progress";
+        case "review":
+            return "Review";
+        case "blocked":
+            return "Blocked";
+        case "done":
+            return "Done";
+    }
+}
+function extractIdFromFilename(file) {
+    const m = /^(TASK-\d+)/i.exec(basename(file));
+    return m ? m[1].toUpperCase() : basename(file, ".md");
+}
+function extractTitleFromBody(body) {
+    const lines = body.split("\n");
+    for (const line of lines) {
+        const m = /^#\s+(.*)$/.exec(line.trim());
+        if (m)
+            return m[1].trim();
+    }
+    return "";
+}
+function extractInlineStatus(body) {
+    const re = /^##\s+Status\s*$/im;
+    const idx = body.search(re);
+    if (idx < 0)
+        return null;
+    const after = body.slice(idx).split("\n");
+    for (let i = 1; i < after.length; i++) {
+        const line = after[i].trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#"))
+            break;
+        return normalizeStatus(line);
+    }
+    return null;
+}
+function extractInlineMvpPhase(body) {
+    const re = /^##\s+MVP Phase\s*$/im;
+    const idx = body.search(re);
+    if (idx < 0)
+        return undefined;
+    const after = body.slice(idx).split("\n");
+    for (let i = 1; i < after.length; i++) {
+        const line = after[i].trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#"))
+            break;
+        return line;
+    }
+    return undefined;
+}
+export async function readTaskFile(filePath) {
+    const raw = await readText(filePath);
+    const parsed = matter(raw);
+    const data = parsed.data;
+    const body = parsed.content;
+    const idFromFm = typeof data["id"] === "string" ? data["id"] : null;
+    const id = idFromFm ?? extractIdFromFilename(filePath);
+    const titleFromFm = typeof data["title"] === "string" ? data["title"] : null;
+    const title = titleFromFm ?? extractTitleFromBody(body);
+    const status = data["status"] !== undefined
+        ? normalizeStatus(data["status"])
+        : (extractInlineStatus(body) ?? "planned");
+    const mvpPhaseFromFm = typeof data["mvpPhase"] === "string" ? data["mvpPhase"] : undefined;
+    const mvpPhase = mvpPhaseFromFm ?? extractInlineMvpPhase(body);
+    const priority = typeof data["priority"] === "string" ? data["priority"] : undefined;
+    return { id, title, status, mvpPhase, priority, filePath };
+}
+export async function scanTasks(tasksDir) {
+    if (!(await isDirectory(tasksDir)))
+        return [];
+    const entries = await readdir(tasksDir, { withFileTypes: true });
+    const files = entries
+        .filter((e) => e.isFile() && e.name.endsWith(".md") && /^TASK-\d+/i.test(e.name))
+        .map((e) => join(tasksDir, e.name))
+        .sort();
+    const out = [];
+    for (const f of files) {
+        try {
+            out.push(await readTaskFile(f));
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return out;
+}
+export function countTasks(tasks) {
+    const counts = {
+        total: tasks.length,
+        planned: 0,
+        in_progress: 0,
+        review: 0,
+        blocked: 0,
+        done: 0,
+    };
+    for (const t of tasks)
+        counts[t.status]++;
+    return counts;
+}
+export function pickNextTask(tasks) {
+    const inProgress = tasks.find((t) => t.status === "in_progress");
+    if (inProgress)
+        return inProgress;
+    const review = tasks.find((t) => t.status === "review");
+    if (review)
+        return review;
+    const planned = tasks.find((t) => t.status === "planned");
+    return planned ?? null;
+}
+export async function findTaskFile(tasksDir, taskId) {
+    const all = await scanTasks(tasksDir);
+    const target = taskId.toUpperCase();
+    for (const t of all) {
+        if (t.id.toUpperCase() === target)
+            return t.filePath;
+    }
+    return null;
+}
+/**
+ * Read the highest TASK number currently present in `tasksDir`.
+ * Considers only filenames that match `TASK-NNN-*.md` (the `TASK-000-template.md`
+ * scaffolding file is included — callers can subtract its `0` if they want to
+ * skip the placeholder).
+ *
+ * Returns 0 if no TASK files exist or the directory is missing.
+ */
+export async function highestTaskNumber(tasksDir) {
+    if (!(await isDirectory(tasksDir)))
+        return 0;
+    const entries = await readdir(tasksDir, { withFileTypes: true });
+    let max = 0;
+    for (const e of entries) {
+        if (!e.isFile() || !e.name.endsWith(".md"))
+            continue;
+        const m = /^TASK-(\d+)/i.exec(e.name);
+        if (!m)
+            continue;
+        const n = Number.parseInt(m[1], 10);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    return max;
+}
+export async function nextTaskNumber(tasksDir) {
+    return (await highestTaskNumber(tasksDir)) + 1;
+}
+export function formatTaskId(n, width = 3) {
+    return `TASK-${String(n).padStart(width, "0")}`;
+}
+const TASK_FILENAME_RE = /^TASK-(\d+)(?:-(.+))?$/i;
+export function parseTaskFilename(filePath) {
+    const stem = basename(filePath, extname(filePath));
+    const m = TASK_FILENAME_RE.exec(stem);
+    if (!m) {
+        return { id: stem.toUpperCase(), number: "000", slug: stem.toLowerCase() };
+    }
+    const number = m[1];
+    const tail = (m[2] ?? "").trim().toLowerCase();
+    const slug = tail.length > 0 ? `${number}-${tail}` : number;
+    return { id: `TASK-${number}`, number, slug };
+}
+export function branchNameForTaskFile(filePath) {
+    return `task/${parseTaskFilename(filePath).slug}`;
+}
+const HEADING_RE = /^(##+)\s+(.+?)\s*$/;
+function locateSection(text, title, level = 2) {
+    const lines = text.split("\n");
+    const wantTitle = title.toLowerCase();
+    for (let i = 0; i < lines.length; i++) {
+        const m = HEADING_RE.exec(lines[i]);
+        if (!m)
+            continue;
+        if (m[1].length !== level)
+            continue;
+        if (m[2].trim().toLowerCase() !== wantTitle)
+            continue;
+        const start = i;
+        const contentStart = i + 1;
+        let j = i + 1;
+        while (j < lines.length) {
+            const nm = HEADING_RE.exec(lines[j]);
+            if (nm && nm[1].length <= level)
+                break;
+            j++;
+        }
+        return { start, end: j, contentStart, level, title: m[2].trim() };
+    }
+    return null;
+}
+export function readSection(body, title) {
+    const block = locateSection(body, title);
+    if (block === null)
+        return "";
+    const lines = body.split("\n").slice(block.contentStart, block.end);
+    // trim leading/trailing blank lines
+    while (lines.length > 0 && lines[0].trim().length === 0)
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim().length === 0)
+        lines.pop();
+    return lines.join("\n");
+}
+export function isPlaceholderContent(content) {
+    const trimmed = content.trim();
+    if (trimmed.length === 0)
+        return true;
+    if (/^\(.*\uBBF8\uC218\uD589.*\)$/.test(trimmed))
+        return true; // legacy Korean placeholder
+    if (/^_*\(none\)_*$/i.test(trimmed))
+        return true;
+    return false;
+}
+export function hasNonEmptySection(body, title) {
+    return !isPlaceholderContent(readSection(body, title));
+}
+export function findExpectedFiles(body) {
+    const content = readSection(body, "Expected Files to Change");
+    if (content.length === 0)
+        return [];
+    const out = [];
+    for (const raw of content.split("\n")) {
+        const line = raw.trim();
+        if (!line.startsWith("- "))
+            continue;
+        let rest = line.slice(2).trim();
+        rest = rest.replace(/^(\uC2E0\uADDC|\uAC31\uC2E0|new|update|update:|\uC2E0\uADDC:|\uAC31\uC2E0:)\s*[:：-]?\s*/i, ""); // matches both English and legacy Korean status prefixes
+        const tickMatch = rest.match(/`([^`]+)`/);
+        if (tickMatch) {
+            out.push(tickMatch[1].trim());
+        }
+        else {
+            const candidate = rest.split(/[\s,]/)[0];
+            if (typeof candidate === "string" && candidate.length > 0 && /[./]/.test(candidate)) {
+                out.push(candidate);
+            }
+        }
+    }
+    return out;
+}
+export function findAcceptanceCriteria(body) {
+    const content = readSection(body, "Acceptance Criteria");
+    if (content.length === 0)
+        return [];
+    const out = [];
+    for (const raw of content.split("\n")) {
+        const line = raw.trim();
+        const m = /^(\d+)\.\s+(.+)$/.exec(line);
+        if (m)
+            out.push(m[2].trim());
+    }
+    return out;
+}
+function replaceSectionContent(body, title, newContent) {
+    const lines = body.split("\n");
+    const block = locateSection(body, title);
+    if (block === null)
+        return body;
+    const before = lines.slice(0, block.contentStart);
+    const after = lines.slice(block.end);
+    const contentLines = ["", newContent.trim(), ""];
+    return [...before, ...contentLines, ...after].join("\n");
+}
+function insertSectionAfter(body, afterTitle, newTitle, newContent) {
+    const block = locateSection(body, afterTitle);
+    const lines = body.split("\n");
+    const newSection = ["", `## ${newTitle}`, "", newContent.trim(), ""];
+    if (block === null) {
+        return [...lines, ...newSection].join("\n");
+    }
+    const before = lines.slice(0, block.end);
+    const after = lines.slice(block.end);
+    return [...before, ...newSection, ...after].join("\n");
+}
+export async function updateInlineStatus(filePath, next) {
+    const raw = await readText(filePath);
+    const display = statusDisplay(next);
+    const updated = replaceSectionContent(raw, "Status", display);
+    if (updated !== raw) {
+        await writeText(filePath, updated);
+    }
+}
+function renderGitContextBlock(ctx) {
+    const lines = [
+        `- Base Branch: \`${ctx.baseBranch}\``,
+        `- Base Commit: \`${ctx.baseCommit}\``,
+        `- Task Branch: \`${ctx.taskBranch}\``,
+        `- Started At: \`${ctx.startedAt}\``,
+    ];
+    if (typeof ctx.doneAt === "string" && ctx.doneAt.length > 0) {
+        lines.push(`- Done At: \`${ctx.doneAt}\``);
+    }
+    return lines.join("\n");
+}
+export async function upsertGitContext(filePath, ctx) {
+    const raw = await readText(filePath);
+    const block = renderGitContextBlock(ctx);
+    let updated;
+    if (locateSection(raw, "Git Context")) {
+        updated = replaceSectionContent(raw, "Git Context", block);
+    }
+    else if (locateSection(raw, "MVP Phase")) {
+        updated = insertSectionAfter(raw, "MVP Phase", "Git Context", block);
+    }
+    else if (locateSection(raw, "Status")) {
+        updated = insertSectionAfter(raw, "Status", "Git Context", block);
+    }
+    else {
+        updated = `${raw.trimEnd()}\n\n## Git Context\n\n${block}\n`;
+    }
+    if (updated !== raw) {
+        await writeText(filePath, updated);
+    }
+}
+const GIT_CTX_RE = {
+    baseBranch: /^-\s+Base Branch:\s*`([^`]+)`/m,
+    baseCommit: /^-\s+Base Commit:\s*`([^`]+)`/m,
+    taskBranch: /^-\s+Task Branch:\s*`([^`]+)`/m,
+    startedAt: /^-\s+Started At:\s*`([^`]+)`/m,
+    doneAt: /^-\s+Done At:\s*`([^`]+)`/m,
+};
+export async function readGitContext(filePath) {
+    const raw = await readText(filePath);
+    const content = readSection(raw, "Git Context");
+    if (content.length === 0)
+        return null;
+    const baseBranch = content.match(GIT_CTX_RE.baseBranch)?.[1];
+    const baseCommit = content.match(GIT_CTX_RE.baseCommit)?.[1];
+    const taskBranch = content.match(GIT_CTX_RE.taskBranch)?.[1];
+    const startedAt = content.match(GIT_CTX_RE.startedAt)?.[1];
+    if (!baseBranch || !baseCommit || !taskBranch || !startedAt)
+        return null;
+    const doneAt = content.match(GIT_CTX_RE.doneAt)?.[1];
+    const ctx = { baseBranch, baseCommit, taskBranch, startedAt };
+    if (typeof doneAt === "string" && doneAt.length > 0)
+        ctx.doneAt = doneAt;
+    return ctx;
+}