@duckmind/dm-darwin-x64 0.43.4 → 0.43.8

package/extensions/dm-tasks/src/process-tracker.ts

@@ -1,140 +0,0 @@
-/**
- * process-tracker.ts — Background process management for tasks.
- *
- * Tracks spawned child processes, buffers their output, and supports
- * blocking wait and graceful stop (SIGTERM → 5s → SIGKILL).
- */
-
-import type { ChildProcess } from "node:child_process";
-import type { BackgroundProcess } from "./types.js";
-
-export interface ProcessOutput {
-  output: string;
-  status: BackgroundProcess["status"];
-  exitCode?: number;
-  startedAt: number;
-  completedAt?: number;
-  command?: string;
-}
-
-export class ProcessTracker {
-  private processes = new Map<string, BackgroundProcess>();
-
-  /** Register a spawned process for a task. */
-  track(taskId: string, proc: ChildProcess, command?: string): void {
-    const bp: BackgroundProcess = {
-      taskId,
-      pid: proc.pid!,
-      command,
-      output: [],
-      status: "running",
-      startedAt: Date.now(),
-      proc,
-      abortController: new AbortController(),
-      waiters: [],
-    };
-
-    // Buffer stdout
-    proc.stdout?.on("data", (data: Buffer) => {
-      bp.output.push(data.toString());
-    });
-
-    // Buffer stderr
-    proc.stderr?.on("data", (data: Buffer) => {
-      bp.output.push(data.toString());
-    });
-
-    // Handle process exit
-    proc.on("close", (code, _signal) => {
-      if (bp.status === "running") {
-        bp.status = code === 0 ? "completed" : "error";
-      }
-      bp.exitCode = code ?? undefined;
-      bp.completedAt = Date.now();
-      // Notify all waiters
-      for (const resolve of bp.waiters) resolve();
-      bp.waiters = [];
-    });
-
-    proc.on("error", (err) => {
-      if (bp.status === "running") {
-        bp.status = "error";
-        bp.output.push(`Process error: ${err.message}`);
-        bp.completedAt = Date.now();
-        for (const resolve of bp.waiters) resolve();
-        bp.waiters = [];
-      }
-    });
-
-    this.processes.set(taskId, bp);
-  }
-
-  /** Get current output and status for a task's process. */
-  getOutput(taskId: string): ProcessOutput | undefined {
-    const bp = this.processes.get(taskId);
-    if (!bp) return undefined;
-    return {
-      output: bp.output.join(""),
-      status: bp.status,
-      exitCode: bp.exitCode,
-      startedAt: bp.startedAt,
-      completedAt: bp.completedAt,
-      command: bp.command,
-    };
-  }
-
-  /** Wait for a task's process to complete, with timeout. */
-  waitForCompletion(taskId: string, timeout: number, signal?: AbortSignal): Promise<ProcessOutput | undefined> {
-    const bp = this.processes.get(taskId);
-    if (!bp) return Promise.resolve(undefined);
-    if (bp.status !== "running") return Promise.resolve(this.getOutput(taskId));
-
-    return new Promise<ProcessOutput | undefined>((resolve) => {
-      let settled = false;
-      const timer = setTimeout(finish, timeout);
-
-      function finish() {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        resolve(self.getOutput(taskId));
-      }
-
-      const self = this;
-      bp.waiters.push(finish);
-      signal?.addEventListener("abort", finish, { once: true });
-    });
-  }
-
-  /** Stop a task's background process. SIGTERM → 5s → SIGKILL. */
-  async stop(taskId: string): Promise<boolean> {
-    const bp = this.processes.get(taskId);
-    if (!bp || bp.status !== "running") return false;
-
-    bp.status = "stopped";
-    bp.proc.kill("SIGTERM");
-
-    // Wait up to 5s for graceful exit
-    await new Promise<void>((resolve) => {
-      const timer = setTimeout(() => {
-        try { bp.proc.kill("SIGKILL"); } catch { /* already dead */ }
-        resolve();
-      }, 5000);
-
-      bp.proc.on("close", () => {
-        clearTimeout(timer);
-        resolve();
-      });
-    });
-
-    bp.completedAt = Date.now();
-    for (const resolve of bp.waiters) resolve();
-    bp.waiters = [];
-    return true;
-  }
-
-  /** Get the process record for a task. */
-  getProcess(taskId: string): BackgroundProcess | undefined {
-    return this.processes.get(taskId);
-  }
-}

package/extensions/dm-tasks/src/task-store.ts

@@ -1,305 +0,0 @@
-/**
- * task-store.ts — File-backed task store with CRUD, dependency management, and file locking.
- *
- * Session-scoped (default): in-memory Map — no disk I/O.
- * Shared (DM_TASKS / PI_TASKS set): ~/.dm/tasks/<listId>.json with file locking.
- */
-
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
-import type { Task, TaskStatus, TaskStoreData } from "./types.js";
-
-const TASKS_DIR = join(homedir(), ".dm", "tasks");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100; // 5s max
-
-/** Simple file-based locking. */
-function acquireLock(lockPath: string): void {
-  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-    try {
-      // O_EXCL: fail if file exists
-      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-      return;
-    } catch (e: any) {
-      if (e.code === "EEXIST") {
-        // Check for stale lock (process no longer running)
-        try {
-          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-          if (pid && !isProcessRunning(pid)) {
-            unlinkSync(lockPath);
-            continue;
-          }
-        } catch { /* ignore read errors */ }
-        // Wait and retry
-        const start = Date.now();
-        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-        continue;
-      }
-      throw e;
-    }
-  }
-  throw new Error(`Failed to acquire lock: ${lockPath}`);
-}
-
-function releaseLock(lockPath: string): void {
-  try { unlinkSync(lockPath); } catch { /* ignore */ }
-}
-
-function isProcessRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-export class TaskStore {
-  private filePath: string | undefined;
-  private lockPath: string | undefined;
-
-  // In-memory state (always kept in sync)
-  private nextId = 1;
-  private tasks = new Map<string, Task>();
-
-  constructor(listIdOrPath?: string) {
-    if (!listIdOrPath) return;
-    const isAbsPath = isAbsolute(listIdOrPath);
-    const filePath = isAbsPath ? listIdOrPath : join(TASKS_DIR, `${listIdOrPath}.json`);
-    mkdirSync(dirname(filePath), { recursive: true });
-    this.filePath = filePath;
-    this.lockPath = filePath + ".lock";
-    this.load();
-  }
-
-  /** Read store from disk (file-backed mode only). */
-  private load(): void {
-    if (!this.filePath) return;
-    if (!existsSync(this.filePath)) return;
-    try {
-      const data: TaskStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
-      this.nextId = data.nextId;
-      this.tasks.clear();
-      for (const t of data.tasks) {
-        this.tasks.set(t.id, t);
-      }
-    } catch { /* corrupt file — start fresh */ }
-  }
-
-  /** Write store to disk atomically (file-backed mode only). */
-  private save(): void {
-    if (!this.filePath) return;
-    const data: TaskStoreData = {
-      nextId: this.nextId,
-      tasks: Array.from(this.tasks.values()),
-    };
-    const tmpPath = this.filePath + ".tmp";
-    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    renameSync(tmpPath, this.filePath);
-  }
-
-  /** Execute a mutation with file locking (if file-backed). */
-  private withLock<T>(fn: () => T): T {
-    if (!this.lockPath) return fn();
-    acquireLock(this.lockPath);
-    try {
-      this.load(); // Re-read latest state
-      const result = fn();
-      this.save();
-      return result;
-    } finally {
-      releaseLock(this.lockPath);
-    }
-  }
-
-  create(subject: string, description: string, activeForm?: string, metadata?: Record<string, any>): Task {
-    return this.withLock(() => {
-      const now = Date.now();
-      const task: Task = {
-        id: String(this.nextId++),
-        subject,
-        description,
-        status: "pending",
-        activeForm,
-        owner: undefined,
-        metadata: metadata ?? {},
-        blocks: [],
-        blockedBy: [],
-        createdAt: now,
-        updatedAt: now,
-      };
-      this.tasks.set(task.id, task);
-      return task;
-    });
-  }
-
-  get(id: string): Task | undefined {
-    if (this.filePath) this.load();
-    return this.tasks.get(id);
-  }
-
-  /** List all tasks sorted by ID ascending. */
-  list(): Task[] {
-    if (this.filePath) this.load();
-    return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
-  }
-
-  update(id: string, fields: {
-    status?: TaskStatus | "deleted";
-    subject?: string;
-    description?: string;
-    activeForm?: string;
-    owner?: string;
-    metadata?: Record<string, any>;
-    addBlocks?: string[];
-    addBlockedBy?: string[];
-  }): { task: Task | undefined; changedFields: string[]; warnings: string[] } {
-    return this.withLock(() => {
-      const task = this.tasks.get(id);
-      if (!task) return { task: undefined, changedFields: [], warnings: [] };
-
-      const changedFields: string[] = [];
-      const warnings: string[] = [];
-
-      // Handle deletion
-      if (fields.status === "deleted") {
-        this.tasks.delete(id);
-        // Clean up dependency edges pointing to this task
-        for (const t of this.tasks.values()) {
-          t.blocks = t.blocks.filter(bid => bid !== id);
-          t.blockedBy = t.blockedBy.filter(bid => bid !== id);
-        }
-        return { task: undefined, changedFields: ["deleted"], warnings: [] };
-      }
-
-      if (fields.status !== undefined) {
-        task.status = fields.status;
-        changedFields.push("status");
-      }
-      if (fields.subject !== undefined) {
-        task.subject = fields.subject;
-        changedFields.push("subject");
-      }
-      if (fields.description !== undefined) {
-        task.description = fields.description;
-        changedFields.push("description");
-      }
-      if (fields.activeForm !== undefined) {
-        task.activeForm = fields.activeForm;
-        changedFields.push("activeForm");
-      }
-      if (fields.owner !== undefined) {
-        task.owner = fields.owner;
-        changedFields.push("owner");
-      }
-
-      // Metadata: shallow merge, null deletes keys
-      if (fields.metadata !== undefined) {
-        for (const [key, value] of Object.entries(fields.metadata)) {
-          if (value === null) {
-            delete task.metadata[key];
-          } else {
-            task.metadata[key] = value;
-          }
-        }
-        changedFields.push("metadata");
-      }
-
-      // Bidirectional dependency edges
-      if (fields.addBlocks && fields.addBlocks.length > 0) {
-        for (const targetId of fields.addBlocks) {
-          if (!task.blocks.includes(targetId)) {
-            task.blocks.push(targetId);
-          }
-          const target = this.tasks.get(targetId);
-          if (target && !target.blockedBy.includes(id)) {
-            target.blockedBy.push(id);
-            target.updatedAt = Date.now();
-          }
-          // Warnings for problematic edges
-          if (targetId === id) {
-            warnings.push(`#${id} blocks itself`);
-          } else if (!target) {
-            warnings.push(`#${targetId} does not exist`);
-          } else if (target.blocks.includes(id)) {
-            warnings.push(`cycle: #${id} and #${targetId} block each other`);
-          }
-        }
-        changedFields.push("blocks");
-      }
-
-      if (fields.addBlockedBy && fields.addBlockedBy.length > 0) {
-        for (const targetId of fields.addBlockedBy) {
-          if (!task.blockedBy.includes(targetId)) {
-            task.blockedBy.push(targetId);
-          }
-          const target = this.tasks.get(targetId);
-          if (target && !target.blocks.includes(id)) {
-            target.blocks.push(id);
-            target.updatedAt = Date.now();
-          }
-          // Warnings for problematic edges
-          if (targetId === id) {
-            warnings.push(`#${id} blocks itself`);
-          } else if (!target) {
-            warnings.push(`#${targetId} does not exist`);
-          } else if (task.blocks.includes(targetId)) {
-            warnings.push(`cycle: #${id} and #${targetId} block each other`);
-          }
-        }
-        changedFields.push("blockedBy");
-      }
-
-      task.updatedAt = Date.now();
-      return { task, changedFields, warnings };
-    });
-  }
-
-  /** Delete a task by ID. Returns true if deleted. */
-  delete(id: string): boolean {
-    return this.withLock(() => {
-      if (!this.tasks.has(id)) return false;
-      this.tasks.delete(id);
-      // Clean up dependency edges
-      for (const t of this.tasks.values()) {
-        t.blocks = t.blocks.filter(bid => bid !== id);
-        t.blockedBy = t.blockedBy.filter(bid => bid !== id);
-      }
-      return true;
-    });
-  }
-
-  /** Remove all tasks. */
-  clearAll(): number {
-    return this.withLock(() => {
-      const count = this.tasks.size;
-      this.tasks.clear();
-      return count;
-    });
-  }
-
-  /** Delete the backing file (if file-backed and empty). */
-  deleteFileIfEmpty(): boolean {
-    if (!this.filePath || this.tasks.size > 0) return false;
-    try { unlinkSync(this.filePath); } catch { /* ignore */ }
-    return true;
-  }
-
-  /** Remove all completed tasks. */
-  clearCompleted(): number {
-    return this.withLock(() => {
-      let count = 0;
-      for (const [id, task] of this.tasks) {
-        if (task.status === "completed") {
-          this.tasks.delete(id);
-          count++;
-        }
-      }
-      // Clean up dependency edges for deleted tasks
-      if (count > 0) {
-        const validIds = new Set(this.tasks.keys());
-        for (const t of this.tasks.values()) {
-          t.blocks = t.blocks.filter(bid => validIds.has(bid));
-          t.blockedBy = t.blockedBy.filter(bid => validIds.has(bid));
-        }
-      }
-      return count;
-    });
-  }
-}

package/extensions/dm-tasks/src/tasks-config.ts

@@ -1,23 +0,0 @@
-// <cwd>/.dm/tasks-config.json — persists extension settings across sessions
-
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-export interface TasksConfig {
-  taskScope?: "memory" | "session" | "project";  // default: "session"
-  autoCascade?: boolean;   // default: false
-  autoClearCompleted?: "never" | "on_list_complete" | "on_task_complete";  // default: "on_list_complete"
-}
-
-const CONFIG_PATH = join(process.cwd(), ".dm", "tasks-config.json");
-
-export function loadTasksConfig(): TasksConfig {
-  try {
-    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-  } catch { return {}; }
-}
-
-export function saveTasksConfig(config: TasksConfig): void {
-  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-}

package/extensions/dm-tasks/src/types.ts

@@ -1,40 +0,0 @@
-/**
- * types.ts — Type definitions for the task management system.
- */
-
-export type TaskStatus = "pending" | "in_progress" | "completed";
-
-export interface Task {
-  id: string;
-  subject: string;
-  description: string;
-  status: TaskStatus;
-  activeForm?: string;
-  owner?: string;
-  metadata: Record<string, any>;
-  blocks: string[];
-  blockedBy: string[];
-  createdAt: number;
-  updatedAt: number;
-}
-
-/** Serialized store format on disk. */
-export interface TaskStoreData {
-  nextId: number;
-  tasks: Task[];
-}
-
-/** Background process associated with a task. */
-export interface BackgroundProcess {
-  taskId: string;
-  pid: number;
-  command?: string;
-  output: string[];
-  status: "running" | "completed" | "error" | "stopped";
-  exitCode?: number;
-  startedAt: number;
-  completedAt?: number;
-  proc: import("node:child_process").ChildProcess;
-  abortController: AbortController;
-  waiters: Array<() => void>;
-}

package/extensions/dm-tasks/src/ui/settings-menu.ts

@@ -1,100 +0,0 @@
-/**
- * settings-menu.ts — Polished settings panel for /tasks → Settings.
- *
- * Uses ui.custom() + SettingsList for native TUI rendering with keyboard
- * navigation, live toggle, and per-row descriptions — matching DM coding-agent's
- * own settings panel style.
- */
-
-import { getSettingsListTheme } from "@duckmind/dm-coding-agent";
-import { Container, type SettingItem, SettingsList, Spacer, Text } from "@duckmind/dm-tui";
-import { saveTasksConfig, type TasksConfig } from "../tasks-config.js";
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export type SettingsUI = {
-  custom<T>(
-    factory: (tui: any, theme: any, keybindings: any, done: (result: T) => void) => any,
-    options?: { overlay?: boolean; overlayOptions?: any },
-  ): Promise<T>;
-};
-
-// ── Settings panel ──────────────────────────────────────────────────────────
-
-export async function openSettingsMenu(
-  ui: SettingsUI,
-  cfg: TasksConfig,
-  onBack: () => Promise<void>,
-  clearDelayTurns: number,
-): Promise<void> {
-  await ui.custom((_tui, theme, _kb, done) => {
-    const items: SettingItem[] = [
-      {
-        id: "taskScope",
-        label: "Task storage",
-        description:
-          "memory: tasks live only in memory, lost when session ends. " +
-          "session: persisted per session (tasks-<sessionId>.json), survives resume. " +
-          "project: shared across all sessions (tasks.json). " +
-          "Takes effect on next session start.",
-        currentValue: cfg.taskScope ?? "session",
-        values: ["memory", "session", "project"],
-      },
-      {
-        id: "autoCascade",
-        label: "Auto-execute with agents",
-        description:
-          "When ON: pending agent tasks start automatically once their dependencies complete. " +
-          "When OFF: use TaskExecute to launch them manually.",
-        currentValue: (cfg.autoCascade ?? false) ? "on" : "off",
-        values: ["on", "off"],
-      },
-      {
-        id: "autoClearCompleted",
-        label: "Auto-clear completed tasks",
-        description:
-          "never: completed tasks stay visible until manually cleared. " +
-          "on_list_complete: cleared automatically after all tasks are done. " +
-          "on_task_complete: each task cleared shortly after it completes. " +
-          `Clearing lags ~${clearDelayTurns} turns.`,
-        currentValue: cfg.autoClearCompleted ?? "on_list_complete",
-        values: ["never", "on_list_complete", "on_task_complete"],
-      },
-    ];
-
-    const list = new SettingsList(
-      items,
-      /* maxVisible */ 10,
-      getSettingsListTheme(),
-      /* onChange */ (id, newValue) => {
-        if (id === "autoCascade") {
-          cfg.autoCascade = newValue === "on";
-          saveTasksConfig(cfg);
-        }
-        if (id === "taskScope") {
-          cfg.taskScope = newValue as "memory" | "session" | "project";
-          saveTasksConfig(cfg);
-        }
-        if (id === "autoClearCompleted") {
-          cfg.autoClearCompleted = newValue as TasksConfig["autoClearCompleted"];
-          saveTasksConfig(cfg);
-        }
-      },
-      /* onCancel */ () => done(undefined),
-    );
-
-    // Container doesn't forward handleInput to children — subclass to fix.
-    class SettingsPanel extends Container {
-      handleInput(data: string) { list.handleInput(data); }
-    }
-
-    const root = new SettingsPanel();
-    root.addChild(new Text(theme.bold(theme.fg("accent", "⚙  Task Settings")), 0, 0));
-    root.addChild(new Spacer(1));
-    root.addChild(list);
-
-    return root;
-  });
-
-  return onBack();
-}