vibeman 0.0.17 → 0.0.18

package/dist/api.js

@@ -105357,7 +105357,7 @@ var init_workflows = __esm(() => {
 
 // ../api/src/server/routes/tasks.ts
 import { normalize as normalize9, resolve as resolve16, join as join5, relative as relative5, sep as sep2 } from "node:path";
-import { writeFile as writeFile3, mkdir as mkdir3 } from "node:fs/promises";
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
 function normalizeFrontmatterTags(value) {
   if (Array.isArray(value)) {
     return value.map((tag) => String(tag).trim()).filter(Boolean);
@@ -105404,6 +105404,117 @@ function runBelongsToTask(payload, plan, explicitTaskId) {
     return true;
   return false;
 }
+function buildTaskDeleteCommitMessage(taskId, taskTitle) {
+  const normalizedId = taskId.trim();
+  const normalizedTitle = taskTitle?.trim() ?? "";
+  const raw2 = `task: ${normalizedId} ${normalizedTitle} deleted`.replace(/\s+/g, " ").trim();
+  return raw2 || `task: ${normalizedId} deleted`;
+}
+async function deleteTaskFileWithCommit(args) {
+  for (const file2 of args.deletedFiles) {
+    await rm2(resolve16(args.rootPath, file2.path), { force: true });
+  }
+  if (!args.commitDirect) {
+    return { commit: null };
+  }
+  try {
+    const commit = await args.git.commit(args.commitMessage, {
+      paths: args.deletedFiles.map((file2) => file2.path)
+    });
+    return { commit };
+  } catch (error48) {
+    try {
+      await Promise.all(args.deletedFiles.map((file2) => writeFile3(resolve16(args.rootPath, file2.path), file2.content)));
+    } catch (restoreError) {
+      const restoreMessage = restoreError instanceof Error ? restoreError.message : "Unknown restore error";
+      const originalMessage = error48 instanceof Error ? error48.message : "Unknown commit error";
+      throw new Error(`Unable to commit task delete (${originalMessage}). The task file could not be restored (${restoreMessage}).`);
+    }
+    throw error48;
+  }
+}
+async function collectRestorableTaskDeleteFiles(args) {
+  const deletedFiles = [
+    { path: args.taskPath, content: args.taskContent }
+  ];
+  const assetPaths = collectTaskAssetPaths(args.taskContent);
+  for (const assetPath of assetPaths) {
+    try {
+      deletedFiles.push({
+        path: assetPath,
+        content: await readFile5(resolve16(args.rootPath, assetPath))
+      });
+    } catch (error48) {
+      if (error48 instanceof Error && error48.code === "ENOENT") {
+        continue;
+      }
+      throw error48;
+    }
+  }
+  return deletedFiles;
+}
+async function cleanupTaskGitArtifacts(rootPath, plan) {
+  const git = createGitService(rootPath);
+  const worktrees = await git.listWorktrees();
+  const normalizedTarget = normalize9(plan.worktreePath);
+  const rootPathNormalized = normalize9(resolve16(rootPath));
+  const matchingWorktrees = worktrees.filter((worktree) => {
+    const resolvedPath = normalize9(resolve16(rootPath, worktree.path));
+    return resolvedPath === normalizedTarget || worktree.branch === plan.branchName;
+  });
+  for (const worktree of matchingWorktrees) {
+    const resolvedPath = normalize9(resolve16(rootPath, worktree.path));
+    const relativePath = relative5(rootPathNormalized, resolvedPath);
+    const isWithinRoot2 = relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`..${sep2}`);
+    if (isWithinRoot2) {
+      continue;
+    }
+    await git.removeWorktree(worktree.path, { force: true });
+  }
+  await git.pruneWorktrees();
+  const hasBranch = await git.branchExists(plan.branchName);
+  if (!hasBranch) {
+    return;
+  }
+  const currentBranch = await git.getCurrentBranch();
+  if (currentBranch === plan.branchName) {
+    const localBranches = await git.listLocalBranches();
+    const fallbackCandidates = [await git.getDefaultBranch(), "main", "master", ...localBranches];
+    const fallbackBranch = fallbackCandidates.find((branch) => branch && branch !== plan.branchName && localBranches.includes(branch)) ?? "";
+    if (!fallbackBranch) {
+      throw new Error(`Cannot delete branch "${plan.branchName}" because it is currently checked out.`);
+    }
+    await git.checkoutBranch(fallbackBranch);
+  }
+  await git.removeBranch(plan.branchName, { force: true });
+}
+async function cleanupTaskWorkflowRuns(args) {
+  let deletedRuns = 0;
+  let cancelledRuns = 0;
+  const runs = await args.db.workflowRun.findMany({
+    where: { deletedAt: null },
+    select: { id: true, status: true, runPayload: true }
+  });
+  const relatedRuns = runs.filter((run2) => runBelongsToTask(run2.runPayload ?? null, args.plan, args.explicitTaskId));
+  const workflowService = createWorkflowService({ db: args.db, root: args.rootPath });
+  const cancellableRuns = relatedRuns.filter((run2) => {
+    const status = String(run2.status).toLowerCase();
+    return status === "running" || status === "pending" || status === "paused";
+  });
+  for (const run2 of cancellableRuns) {
+    await workflowService.cancelRun(run2.id, args.cancelReason);
+    cancelledRuns += 1;
+  }
+  const runIds = relatedRuns.map((run2) => run2.id);
+  if (runIds.length > 0) {
+    const result = await args.db.workflowRun.updateMany({
+      where: { id: { in: runIds } },
+      data: { deletedAt: new Date }
+    });
+    deletedRuns = result.count;
+  }
+  return { deletedRuns, cancelledRuns };
+}
 function parseTaskFile(filename, content) {
   const parsed = import_gray_matter2.default(content);
   const frontmatter = { ...parsed.data };
@@ -105449,6 +105560,7 @@ var init_tasks2 = __esm(() => {
   init_log();
   init_task_markdown();
   init_task_id();
+  init_task_commit_paths();
   init_tasks();
   init_workflows();
   init_trpc();
@@ -105804,44 +105916,8 @@ var init_tasks2 = __esm(() => {
           cause: error48 instanceof Error ? error48 : undefined
         });
       }
-      const git = createGitService(ctx.root);
       try {
-        const worktrees = await git.listWorktrees();
-        const normalizedTarget = normalize9(plan.worktreePath);
-        const rootPath = normalize9(resolve16(ctx.root));
-        const matchingWorktrees = worktrees.filter((worktree) => {
-          const resolvedPath = normalize9(resolve16(ctx.root, worktree.path));
-          return resolvedPath === normalizedTarget || worktree.branch === plan.branchName;
-        });
-        for (const worktree of matchingWorktrees) {
-          const resolvedPath = normalize9(resolve16(ctx.root, worktree.path));
-          const relativePath = relative5(rootPath, resolvedPath);
-          const isWithinRoot2 = relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`..${sep2}`);
-          if (isWithinRoot2) {
-            continue;
-          }
-          await git.removeWorktree(worktree.path, { force: true });
-        }
-        await git.pruneWorktrees();
-        const hasBranch = await git.branchExists(plan.branchName);
-        if (hasBranch) {
-          const currentBranch = await git.getCurrentBranch();
-          if (currentBranch === plan.branchName) {
-            const localBranches = await git.listLocalBranches();
-            const fallbackCandidates = [
-              await git.getDefaultBranch(),
-              "main",
-              "master",
-              ...localBranches
-            ];
-            const fallbackBranch = fallbackCandidates.find((branch) => branch && branch !== plan.branchName && localBranches.includes(branch)) ?? "";
-            if (!fallbackBranch) {
-              throw new Error(`Cannot delete branch "${plan.branchName}" because it is currently checked out.`);
-            }
-            await git.checkoutBranch(fallbackBranch);
-          }
-          await git.removeBranch(plan.branchName, { force: true });
-        }
+        await cleanupTaskGitArtifacts(ctx.root, plan);
       } catch (error48) {
         const message = error48 instanceof Error ? error48.message : "Unable to reset git worktree and branch";
         throw new TRPCError({
@@ -105853,28 +105929,13 @@ var init_tasks2 = __esm(() => {
       let deletedRuns = 0;
       let cancelledRuns = 0;
       try {
-        const runs = await ctx.db.workflowRun.findMany({
-          where: { deletedAt: null },
-          select: { id: true, status: true, runPayload: true }
-        });
-        const relatedRuns = runs.filter((run2) => runBelongsToTask(run2.runPayload ?? null, plan, input.taskId));
-        const workflowService = createWorkflowService({ db: ctx.db, root: ctx.root });
-        const cancellableRuns = relatedRuns.filter((run2) => {
-          const status = String(run2.status).toLowerCase();
-          return status === "running" || status === "pending" || status === "paused";
-        });
-        for (const run2 of cancellableRuns) {
-          await workflowService.cancelRun(run2.id, "Cancelled by task reset");
-          cancelledRuns += 1;
-        }
-        const runIds = relatedRuns.map((run2) => run2.id);
-        if (runIds.length > 0) {
-          const result = await ctx.db.workflowRun.updateMany({
-            where: { id: { in: runIds } },
-            data: { deletedAt: new Date }
-          });
-          deletedRuns = result.count;
-        }
+        ({ deletedRuns, cancelledRuns } = await cleanupTaskWorkflowRuns({
+          db: ctx.db,
+          rootPath: ctx.root,
+          plan,
+          explicitTaskId: input.taskId,
+          cancelReason: "Cancelled by task reset"
+        }));
       } catch (error48) {
         const message = error48 instanceof Error ? error48.message : "Unable to reset workflow runs and states for task";
         throw new TRPCError({
@@ -105892,6 +105953,112 @@ var init_tasks2 = __esm(() => {
         deletedRuns
       });
     }),
+    delete: dbProcedure.input(exports_external.object({
+      filename: exports_external.string().min(1),
+      taskId: exports_external.string().min(1).optional(),
+      commitDirect: exports_external.boolean().optional(),
+      commitMessage: exports_external.string().min(1).optional()
+    })).mutation(async ({ ctx, input }) => {
+      const taskPath = join5(".vibeman/tasks", input.filename);
+      let plan;
+      let taskTitle;
+      let existingContent = "";
+      try {
+        plan = buildTaskExecutionPlan(ctx.root, taskPath);
+        existingContent = await readFileContent(ctx.root, taskPath);
+        const parsed = import_gray_matter2.default(existingContent);
+        taskTitle = typeof parsed.data.title === "string" ? parsed.data.title : undefined;
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : "Unable to prepare task delete plan";
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message,
+          cause: error48 instanceof Error ? error48 : undefined
+        });
+      }
+      let deletedFiles;
+      try {
+        deletedFiles = await collectRestorableTaskDeleteFiles({
+          rootPath: ctx.root,
+          taskPath,
+          taskContent: existingContent
+        });
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : "Unable to prepare task attachments for delete";
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message,
+          cause: error48 instanceof Error ? error48 : undefined
+        });
+      }
+      const commitDirect = input.commitDirect ?? true;
+      let commitResult = null;
+      const git = createGitService(ctx.root);
+      if (commitDirect) {
+        try {
+          ({ commit: commitResult } = await deleteTaskFileWithCommit({
+            rootPath: ctx.root,
+            deletedFiles,
+            commitDirect,
+            commitMessage: input.commitMessage?.trim() || buildTaskDeleteCommitMessage(plan.taskId, taskTitle),
+            git
+          }));
+        } catch (error48) {
+          const message = error48 instanceof Error ? error48.message : "Unable to commit task delete";
+          throw new TRPCError({
+            code: "BAD_REQUEST",
+            message,
+            cause: error48 instanceof Error ? error48 : undefined
+          });
+        }
+      } else {
+        try {
+          ({ commit: commitResult } = await deleteTaskFileWithCommit({
+            rootPath: ctx.root,
+            deletedFiles,
+            commitDirect,
+            commitMessage: "",
+            git
+          }));
+        } catch (error48) {
+          const message = error48 instanceof Error ? error48.message : "Unable to delete task file";
+          throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message,
+            cause: error48 instanceof Error ? error48 : undefined
+          });
+        }
+      }
+      let deletedRuns = 0;
+      let cancelledRuns = 0;
+      const cleanupWarnings = [];
+      try {
+        await cleanupTaskGitArtifacts(ctx.root, plan);
+      } catch (error48) {
+        cleanupWarnings.push(error48 instanceof Error ? error48.message : "Unable to delete task worktree and branch");
+      }
+      try {
+        ({ deletedRuns, cancelledRuns } = await cleanupTaskWorkflowRuns({
+          db: ctx.db,
+          rootPath: ctx.root,
+          plan,
+          explicitTaskId: input.taskId,
+          cancelReason: "Cancelled by task delete"
+        }));
+      } catch (error48) {
+        cleanupWarnings.push(error48 instanceof Error ? error48.message : "Unable to delete workflow runs and states for task");
+      }
+      return createResponse(ctx, {
+        taskPath: plan.taskPath,
+        taskName: plan.taskName,
+        branch: plan.branchName,
+        worktree: plan.worktreePath,
+        cancelledRuns,
+        deletedRuns,
+        commit: commitResult,
+        cleanupWarnings
+      });
+    }),
     setup: dbProcedure.input(exports_external.object({ filename: exports_external.string().min(1) })).mutation(async ({ ctx, input }) => {
       const taskPath = join5(".vibeman/tasks", input.filename);
       let plan;
@@ -105969,7 +106136,7 @@ function classifyMergeReadiness(input) {
 
 // ../api/src/server/routes/workflows.ts
 import { normalize as normalize10, relative as relative6, resolve as resolve17 } from "node:path";
-import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
 import { execFile as execFile4 } from "node:child_process";
 import { promisify } from "node:util";
 function workflowRecency(workflow) {
@@ -106395,7 +106562,7 @@ function resolvePathWithinRoot(rootPath, pathInput) {
 }
 async function markTaskFrontmatterDone(rootPath, taskPath) {
   const filePath = resolvePathWithinRoot(rootPath, taskPath);
-  const raw2 = await readFile5(filePath, "utf8");
+  const raw2 = await readFile6(filePath, "utf8");
   const match = raw2.match(/^---\n([\s\S]*?)\n---\n?/);
   if (!match) {
     return false;
@@ -108011,7 +108178,7 @@ var init_remote_access = __esm(() => {
 // ../api/src/server/routes/system.ts
 import { execFile as execFile5, spawn as spawn7 } from "node:child_process";
 import { resolve as resolve18, relative as relative7, sep as sep3, join as join6, extname } from "node:path";
-import { access as access3, mkdtemp, readFile as readFile6, rm as rm2 } from "node:fs/promises";
+import { access as access3, mkdtemp, readFile as readFile7, rm as rm3 } from "node:fs/promises";
 import { homedir as homedir2, tmpdir as tmpdir2 } from "node:os";
 import { promisify as promisify2 } from "node:util";
 function isWithin2(rootPath, targetPath) {
@@ -108103,10 +108270,10 @@ async function convertIcnsToPngDataUrl(iconPath) {
   const pngPath = join6(tempDir, "icon.png");
   try {
     await execFileAsync2("sips", ["-s", "format", "png", iconPath, "--out", pngPath]);
-    const pngBuffer = await readFile6(pngPath);
+    const pngBuffer = await readFile7(pngPath);
     return toDataUrl(pngBuffer, ".png");
   } finally {
-    await rm2(tempDir, { recursive: true, force: true });
+    await rm3(tempDir, { recursive: true, force: true });
   }
 }
 async function readAppIconDataUrl(appPath) {
@@ -108131,7 +108298,7 @@ async function readAppIconDataUrl(appPath) {
     const iconPath = join6(appPath, "Contents", "Resources", iconFileName);
     await access3(iconPath);
     const extension = extname(iconPath).toLowerCase();
-    const dataUrl = extension === ".icns" ? await convertIcnsToPngDataUrl(iconPath) : toDataUrl(await readFile6(iconPath), extension);
+    const dataUrl = extension === ".icns" ? await convertIcnsToPngDataUrl(iconPath) : toDataUrl(await readFile7(iconPath), extension);
     appIconCache.set(appPath, dataUrl);
     return dataUrl;
   } catch {
@@ -113781,7 +113948,7 @@ var init_feedback2 = __esm(() => {
 });
 
 // ../api/src/server/routes/onboarding.ts
-import { readFile as readFile7, readdir as readdir4, rename as rename2, rm as rm3, mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile8, readdir as readdir4, rename as rename2, rm as rm4, mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
 import { basename as basename2, join as join8, resolve as resolve21 } from "node:path";
 import { spawn as spawn8 } from "node:child_process";
 function buildInitialOnboardingState(nowIso) {
@@ -113913,7 +114080,7 @@ function buildTemplateWorkspace(root) {
 async function patchGeneratedPackageName(root, desiredName) {
   const packageJsonPath = resolve21(root, "package.json");
   try {
-    const raw2 = await readFile7(packageJsonPath, "utf8");
+    const raw2 = await readFile8(packageJsonPath, "utf8");
     const pkg = JSON.parse(raw2);
     const currentName = typeof pkg.name === "string" ? pkg.name.trim() : "";
     if (currentName.length === 0 || currentName.includes("vibeman-init-tmp")) {
@@ -113932,7 +114099,7 @@ async function patchGeneratedT3ImportAlias(root, desiredAlias) {
   }
   const tsconfigPath = resolve21(root, "tsconfig.json");
   try {
-    const raw2 = await readFile7(tsconfigPath, "utf8");
+    const raw2 = await readFile8(tsconfigPath, "utf8");
     const config2 = JSON.parse(raw2);
     const paths = config2.compilerOptions?.paths;
     const current = paths?.["~/*"];
@@ -114134,7 +114301,7 @@ var init_onboarding = __esm(() => {
       let packageName = null;
       let packageDescription = null;
       try {
-        const raw2 = await readFile7(resolve21(ctx.root, "package.json"), "utf8");
+        const raw2 = await readFile8(resolve21(ctx.root, "package.json"), "utf8");
         const pkg = JSON.parse(raw2);
         if (typeof pkg.name === "string" && pkg.name.trim()) {
           packageName = pkg.name.trim();
@@ -114164,7 +114331,7 @@ var init_onboarding = __esm(() => {
       } catch {}
       if (hasPackageJson) {
         try {
-          const raw2 = await readFile7(resolve21(ctx.root, "package.json"), "utf8");
+          const raw2 = await readFile8(resolve21(ctx.root, "package.json"), "utf8");
           const pkg = JSON.parse(raw2);
           const all = { ...pkg.dependencies, ...pkg.devDependencies };
           if (all["next"] && all["@trpc/server"])
@@ -114204,13 +114371,13 @@ var init_onboarding = __esm(() => {
       const scaffoldPath = shouldRunInTmpDir ? resolve21(tmpPath, workspace.projectDirName) : resolve21(ctx.root, workspace.scaffoldDir);
       const command = buildTemplateInitCommand(input, commandTargetDir);
       try {
-        await rm3(tmpPath, { recursive: true, force: true });
+        await rm4(tmpPath, { recursive: true, force: true });
       } catch {}
       await mkdir6(tmpPath, { recursive: true });
       const result = await runShellCommand(command, commandCwd);
       if (!result.success) {
         try {
-          await rm3(tmpPath, { recursive: true, force: true });
+          await rm4(tmpPath, { recursive: true, force: true });
         } catch {}
         const detail = (result.stderr || result.stdout).trim().slice(-2000);
         throw new TRPCError({
@@ -114241,7 +114408,7 @@ ${detail}`
         throw new TRPCError({ code: "INTERNAL_SERVER_ERROR", message: msg });
       } finally {
         try {
-          await rm3(tmpPath, { recursive: true, force: true });
+          await rm4(tmpPath, { recursive: true, force: true });
         } catch {}
       }
       return createResponse(ctx, {

package/dist/commit.txt

@@ -1 +1 @@
-c6c1e8d
+4d46e83