npm - @ronkovic/aad - Versions diffs - 0.3.9 → 0.4.0 - Mend

@ronkovic/aad 0.3.9 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (114) hide show

package/src/modules/dashboard/ui/dashboard.html CHANGED Viewed

@@ -10,9 +10,15 @@
     header{background:#2d2d2d;padding:20px 24px;border-radius:10px;margin-bottom:20px;display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:10px}
     header h1{font-size:22px;font-weight:700;color:#4fc3f7}
     header p{color:#9e9e9e;font-size:13px}
-    .conn-badge{font-size:11px;padding:4px 10px;border-radius:12px;font-weight:600}
-    .conn-badge.connected{background:#66bb6a33;color:#66bb6a}
-    .conn-badge.disconnected{background:#ef535033;color:#ef5350}
+    .activity-cell{font-size:11px;font-weight:600}
+    .activity-connected{color:#66bb6a}
+    .activity-reconnecting{color:#ffa726}
+    .activity-disconnected{color:#ef5350}
+    .activity-phase-red{color:#ef5350}
+    .activity-phase-green{color:#66bb6a}
+    .activity-phase-verify{color:#42a5f5}
+    .activity-phase-review{color:#ab47bc}
+    .activity-phase-merge{color:#ffa726}
     /* Progress bar */
     .progress-section{background:#2d2d2d;border-radius:10px;padding:20px 24px;margin-bottom:20px}
@@ -95,7 +101,6 @@
 <body>
   <header>
     <div><h1>AAD Dashboard</h1><p>Real-time Task Orchestrator Monitor</p></div>
-    <span class="conn-badge disconnected" id="conn-status">Disconnected</span>
   </header>
   <!-- Progress Bar -->
@@ -130,8 +135,8 @@
     <h2>Tasks <span class="count" id="tasks-count"></span></h2>
     <div class="task-table-wrap">
       <table>
-        <thead><tr><th>ID</th><th>Title</th><th>Status</th><th>Priority</th><th>Dependencies</th></tr></thead>
-        <tbody id="task-tbody"><tr><td colspan="5" class="empty-msg">No tasks</td></tr></tbody>
+        <thead><tr><th>ID</th><th>Title</th><th>Status</th><th>Activity</th><th>Priority</th><th>Dependencies</th></tr></thead>
+        <tbody id="task-tbody"><tr><td colspan="6" class="empty-msg">No tasks</td></tr></tbody>
       </table>
     </div>
   </div>
@@ -150,6 +155,8 @@
       <label><input type="checkbox" checked data-level="warn"> Warn</label>
       <label><input type="checkbox" checked data-level="error"> Error</label>
       <select id="svc-filter"><option value="">All Services</option></select>
+      <input type="text" id="log-search" placeholder="Search logs..." style="background:#3a3a3a;color:#e0e0e0;border:1px solid #555;border-radius:4px;padding:4px 10px;font-size:12px;width:160px">
+      <button id="filter-reset" style="background:#4fc3f7;color:#1a1a1a;border:none;border-radius:4px;padding:4px 10px;font-size:12px;font-weight:600;cursor:pointer;transition:background .2s">Reset</button>
     </div>
     <div class="log-entries" id="log-entries"></div>
   </div>
@@ -159,7 +166,10 @@
     let allTasks = [];
     let logEntries = [];
     let knownServices = new Set();
-    let logFilters = { info: true, warn: true, error: true, service: '' };
+    let logFilters = { info: true, warn: true, error: true, service: '', search: '' };
+    let taskPhases = {}; // { [taskId]: { phase, status } }
+    let sseStatus = 'disconnected'; // Global SSE connection state
+    let reconnectAttempts = 0;
     // --- Data fetching ---
     async function loadAll() {
@@ -212,13 +222,49 @@
     function renderTasks() {
       const tbody = document.getElementById('task-tbody');
       document.getElementById('tasks-count').textContent = '(' + allTasks.length + ')';
-      if (!allTasks.length) { tbody.innerHTML = '<tr><td colspan="5" class="empty-msg">No tasks</td></tr>'; return; }
+      if (!allTasks.length) { tbody.innerHTML = '<tr><td colspan="6" class="empty-msg">No tasks</td></tr>'; return; }
       tbody.innerHTML = allTasks.map(t => {
         const deps = (t.dependsOn || []).map(d => esc(String(d))).join(', ') || '—';
-        return '<tr><td style="font-family:monospace;font-size:11px">' + esc(String(t.taskId)) + '</td><td>' + esc(t.title || '—') + '</td><td><span class="badge badge-' + t.status + '">' + t.status + '</span></td><td class="priority">' + (t.priority || 0) + '</td><td class="deps">' + deps + '</td></tr>';
+        const activity = getActivityDisplay(t.taskId, t.status);
+        return '<tr><td style="font-family:monospace;font-size:11px">' + esc(String(t.taskId)) + '</td><td>' + esc(t.title || '—') + '</td><td><span class="badge badge-' + t.status + '">' + t.status + '</span></td><td class="activity-cell">' + activity + '</td><td class="priority">' + (t.priority || 0) + '</td><td class="deps">' + deps + '</td></tr>';
       }).join('');
     }
+    function getActivityDisplay(taskId, status) {
+      if (status === 'running') {
+        const phaseInfo = taskPhases[taskId];
+        if (phaseInfo) {
+          const phaseLabels = { red: 'Red (Tests)', green: 'Green (Impl)', verify: 'Verify', review: 'Review', merge: 'Merge' };
+          const phaseLabel = phaseLabels[phaseInfo.phase] || phaseInfo.phase;
+          if (phaseInfo.status === 'running') {
+            return '<span class="activity-phase-' + phaseInfo.phase + '">' + esc(phaseLabel) + '</span>';
+          } else if (phaseInfo.status === 'completed') {
+            return '<span class="activity-phase-' + phaseInfo.phase + '">✓ ' + esc(phaseLabel) + '</span>';
+          } else if (phaseInfo.status === 'failed') {
+            return '<span class="activity-phase-' + phaseInfo.phase + '">✗ ' + esc(phaseLabel) + '</span>';
+          }
+        }
+        return '<span class="activity-phase-green">Running</span>';
+      } else {
+        // Non-RUNNING: show SSE connection status
+        if (sseStatus === 'connected') {
+          return '<span class="activity-connected">Connected</span>';
+        } else if (sseStatus === 'reconnecting') {
+          return '<span class="activity-reconnecting">Reconnecting...</span>';
+        } else {
+          return '<span class="activity-disconnected">Disconnected</span>';
+        }
+      }
+    }
+    function updateActivityColumn(taskId) {
+      renderTasks();
+    }
+    function updateAllActivityColumns() {
+      renderTasks();
+    }
     function updateTaskInList(taskId, updates) {
       const idx = allTasks.findIndex(t => t.taskId === taskId);
       if (idx >= 0) Object.assign(allTasks[idx], updates);
@@ -340,30 +386,94 @@
     }
     function applyLogFilterToEntry(div) {
-      const show = logFilters[div.dataset.level] && (!logFilters.service || div.dataset.service === logFilters.service);
+      let show = logFilters[div.dataset.level] && (!logFilters.service || div.dataset.service === logFilters.service);
+      if (show && logFilters.search) {
+        const searchLower = logFilters.search.toLowerCase();
+        const text = div.textContent.toLowerCase();
+        show = text.includes(searchLower);
+      }
       div.classList.toggle('log-hidden', !show);
-      updateLogCount();
     }
     function updateLogCount() {
+      const total = logEntries.length;
       const visible = document.querySelectorAll('#log-entries .log-entry:not(.log-hidden)').length;
-      document.getElementById('log-count').textContent = '(' + visible + ')';
+      document.getElementById('log-count').textContent = '(Showing ' + visible + '/' + total + ')';
+    }
+    // Load filters from localStorage
+    function loadFiltersFromStorage() {
+      try {
+        const saved = localStorage.getItem('aad-log-filters');
+        if (saved) {
+          const parsed = JSON.parse(saved);
+          logFilters = { ...logFilters, ...parsed };
+          document.querySelectorAll('.log-filters input[data-level]').forEach(cb => {
+            cb.checked = logFilters[cb.dataset.level] !== false;
+          });
+          const svcSelect = document.getElementById('svc-filter');
+          if (svcSelect && logFilters.service) svcSelect.value = logFilters.service;
+          const searchInput = document.getElementById('log-search');
+          if (searchInput && logFilters.search) searchInput.value = logFilters.search;
+        }
+      } catch (e) { console.error('Failed to load filters:', e); }
+    }
+    // Save filters to localStorage
+    function saveFiltersToStorage() {
+      try {
+        localStorage.setItem('aad-log-filters', JSON.stringify(logFilters));
+      } catch (e) { console.error('Failed to save filters:', e); }
+    }
+    // Reset filters
+    function resetFilters() {
+      logFilters = { info: true, warn: true, error: true, service: '', search: '' };
+      document.querySelectorAll('.log-filters input[data-level]').forEach(cb => {
+        cb.checked = true;
+      });
+      document.getElementById('svc-filter').value = '';
+      document.getElementById('log-search').value = '';
+      saveFiltersToStorage();
+      applyLogFilters();
     }
     // Filter event listeners
     document.querySelectorAll('.log-filters input[data-level]').forEach(cb => {
-      cb.addEventListener('change', () => { logFilters[cb.dataset.level] = cb.checked; applyLogFilters(); });
+      cb.addEventListener('change', () => {
+        logFilters[cb.dataset.level] = cb.checked;
+        saveFiltersToStorage();
+        applyLogFilters();
+      });
+    });
+    document.getElementById('svc-filter').addEventListener('change', function() {
+      logFilters.service = this.value;
+      saveFiltersToStorage();
+      applyLogFilters();
     });
-    document.getElementById('svc-filter').addEventListener('change', function() { logFilters.service = this.value; applyLogFilters(); });
+    document.getElementById('log-search').addEventListener('input', function() {
+      logFilters.search = this.value;
+      saveFiltersToStorage();
+      applyLogFilters();
+    });
+    document.getElementById('filter-reset').addEventListener('click', resetFilters);
     // --- SSE ---
     let evtSource;
     function connectSSE() {
       if (evtSource) { try { evtSource.close(); } catch(e){} }
       evtSource = new EventSource('/events/all');
-      const badge = document.getElementById('conn-status');
-      evtSource.addEventListener('open', () => { badge.textContent = 'Connected'; badge.className = 'conn-badge connected'; });
+      evtSource.addEventListener('open', () => {
+        reconnectAttempts = 0;
+        sseStatus = 'connected';
+        updateAllActivityColumns();
+      });
+      evtSource.addEventListener('heartbeat', () => {
+        sseStatus = 'connected';
+        updateAllActivityColumns();
+      });
       evtSource.addEventListener('message', (e) => {
         try {
@@ -371,6 +481,18 @@
           switch (ev.type) {
             case 'log:entry': addLogEntry(ev.entry || ev); break;
             case 'progress:updated': updateProgress(ev.state ? { progress: ev.state, percentComplete: ev.percentComplete } : ev); break;
+            case 'execution:phase:started':
+              taskPhases[ev.taskId] = { phase: ev.phase, status: 'running' };
+              updateActivityColumn(ev.taskId);
+              break;
+            case 'execution:phase:completed':
+              taskPhases[ev.taskId] = { phase: ev.phase, status: 'completed' };
+              updateActivityColumn(ev.taskId);
+              break;
+            case 'execution:phase:failed':
+              taskPhases[ev.taskId] = { phase: ev.phase, status: 'failed' };
+              updateActivityColumn(ev.taskId);
+              break;
             case 'task:dispatched':
             case 'task:completed':
             case 'task:failed':
@@ -388,9 +510,11 @@
       });
       evtSource.addEventListener('error', () => {
-        badge.textContent = 'Disconnected'; badge.className = 'conn-badge disconnected';
+        reconnectAttempts++;
+        sseStatus = reconnectAttempts > 3 ? 'disconnected' : 'reconnecting';
+        updateAllActivityColumns();
         evtSource.close();
-        setTimeout(connectSSE, 3000);
+        setTimeout(connectSSE, Math.min(reconnectAttempts * 3000, 9000));
       });
     }
@@ -398,6 +522,7 @@
     function esc(s) { const d = document.createElement('div'); d.textContent = s; return d.innerHTML; }
     // Init
+    loadFiltersFromStorage();
     loadAll();
     connectSSE();
   </script>

package/src/modules/git-workspace/__tests__/branch-manager.test.ts CHANGED Viewed

@@ -199,6 +199,58 @@ describe("BranchManager", () => {
       );
     });
+    test("excludes branches matching excludePatterns (default: /parent)", async () => {
+      const branches = ["feat/run-001/task-001", "feat/run-001/parent", "aad-task-x"];
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        callCount++;
+        if (args[0] === "branch" && args[1] === "--list") {
+          // Only return branches for the first conventional prefix pattern
+          if (callCount === 1) {
+            return { stdout: branches.slice(0, 2).join("\n"), stderr: "", exitCode: 0 };
+          }
+          // aad-* pattern
+          if (args[2] === "aad-*") {
+            return { stdout: branches[2] ?? "", stderr: "", exitCode: 0 };
+          }
+          return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+      const deleted = await branchManager.cleanupOrphanBranches();
+      // feat/run-001/parent はスキップ、他2つは削除
+      expect(deleted).not.toContain("feat/run-001/parent");
+      expect(deleted.length).toBe(2);
+    });
+    test("deletes all branches when excludePatterns is empty array", async () => {
+      const branches = ["feat/run-001/parent", "feat/run-001/task-001"];
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        if (args[0] === "branch" && args[1] === "--list") {
+          if (args[2]?.startsWith("feat/")) {
+            return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+          }
+          return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+      const deleted = await branchManager.cleanupOrphanBranches(undefined, {
+        force: false,
+        excludePatterns: [],
+      });
+      // parent含めて全削除
+      expect(deleted).toContain("feat/run-001/parent");
+    });
+    test("supports legacy boolean argument (backward compat)", async () => {
+      mockGitOps.gitExec = mock(async () => ({ stdout: "", stderr: "", exitCode: 0 }));
+      const deleted = await branchManager.cleanupOrphanBranches(undefined, true);
+      expect(deleted).toEqual([]);
+      // No error = backward compat OK
+    });
     test("cleans up orphan branches for specific runId", async () => {
       const runId = createRunId("run-001");
       const branches = ["aad-task-run-001-01", "aad-run-run-001"];

package/src/modules/git-workspace/__tests__/dependency-installer.test.ts ADDED Viewed

@@ -0,0 +1,77 @@
+import { describe, test, expect } from "bun:test";
+import { buildInstallCommand } from "../dependency-installer";
+import type { WorkspaceInfo } from "../../../shared/types";
+describe("buildInstallCommand", () => {
+  // Helper to create minimal WorkspaceInfo
+  const createWorkspace = (packageManager: WorkspaceInfo["packageManager"]): WorkspaceInfo => ({
+    path: "/tmp/test",
+    language: "typescript",
+    packageManager,
+    framework: "none",
+    testFramework: "bun-test",
+  });
+  describe("Node.js ecosystem", () => {
+    test("bun → bun install --frozen-lockfile", () => {
+      const result = buildInstallCommand(createWorkspace("bun"));
+      expect(result).toEqual(["bun", "install", "--frozen-lockfile"]);
+    });
+    test("npm → npm ci", () => {
+      const result = buildInstallCommand(createWorkspace("npm"));
+      expect(result).toEqual(["npm", "ci"]);
+    });
+    test("yarn → yarn install --frozen-lockfile", () => {
+      const result = buildInstallCommand(createWorkspace("yarn"));
+      expect(result).toEqual(["yarn", "install", "--frozen-lockfile"]);
+    });
+    test("pnpm → pnpm install --frozen-lockfile", () => {
+      const result = buildInstallCommand(createWorkspace("pnpm"));
+      expect(result).toEqual(["pnpm", "install", "--frozen-lockfile"]);
+    });
+  });
+  describe("Python ecosystem", () => {
+    test("uv → uv sync", () => {
+      const result = buildInstallCommand(createWorkspace("uv"));
+      expect(result).toEqual(["uv", "sync"]);
+    });
+    test("poetry → poetry install --no-interaction", () => {
+      const result = buildInstallCommand(createWorkspace("poetry"));
+      expect(result).toEqual(["poetry", "install", "--no-interaction"]);
+    });
+    test("pipenv → pipenv install", () => {
+      const result = buildInstallCommand(createWorkspace("pipenv"));
+      expect(result).toEqual(["pipenv", "install"]);
+    });
+    test("pip → pip install -r requirements.txt", () => {
+      const result = buildInstallCommand(createWorkspace("pip"));
+      expect(result).toEqual(["pip", "install", "-r", "requirements.txt"]);
+    });
+  });
+  describe("Go/Rust ecosystem", () => {
+    test("go → go mod download", () => {
+      const result = buildInstallCommand(createWorkspace("go"));
+      expect(result).toEqual(["go", "mod", "download"]);
+    });
+    test("cargo → cargo fetch", () => {
+      const result = buildInstallCommand(createWorkspace("cargo"));
+      expect(result).toEqual(["cargo", "fetch"]);
+    });
+  });
+  describe("Unknown/No-op package managers", () => {
+    test("unknown → null", () => {
+      const result = buildInstallCommand(createWorkspace("unknown"));
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/modules/git-workspace/__tests__/git-exec.test.ts CHANGED Viewed

@@ -88,4 +88,30 @@ describe("git-exec", () => {
       expect(exists).toBe(false);
     });
   });
+  describe("allowNonZeroExit option", () => {
+    test("does not throw on non-zero exit when allowNonZeroExit is true", async () => {
+      // git diff --cached --quiet は変更なしで exit 0
+      const result = await gitExec(["diff", "--cached", "--quiet"], {
+        cwd: TEST_DIR,
+        allowNonZeroExit: true,
+      });
+      expect(result.exitCode).toBe(0);
+    });
+    test("returns non-zero exitCode without throwing", async () => {
+      // 存在しないref → exit 128
+      const result = await gitExec(["rev-parse", "--verify", "nonexistent-ref"], {
+        cwd: TEST_DIR,
+        allowNonZeroExit: true,
+      });
+      expect(result.exitCode).not.toBe(0);
+    });
+    test("still throws when allowNonZeroExit is false (default)", async () => {
+      await expect(
+        gitExec(["rev-parse", "--verify", "nonexistent-ref"], { cwd: TEST_DIR })
+      ).rejects.toThrow("Git command failed");
+    });
+  });
 });

package/src/modules/git-workspace/__tests__/merge-service.test.ts CHANGED Viewed

@@ -111,6 +111,25 @@ describe("MergeService", () => {
       expect(result.message).toContain("Successfully merged");
     }, 60_000);
+    test("sets alreadyUpToDate when task branch has no new commits", async () => {
+      const mergeService = await resetWorktree();
+      // taskBranch = 現在のHEADと同じ → Already up to date
+      const taskBranch = "task-no-changes";
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await gitExec(["branch", taskBranch], { cwd: PARENT_WORKTREE });
+      const result = await mergeService.mergeToParent(
+        createTaskId("task-noop"),
+        taskBranch,
+        DEFAULT_BRANCH,
+        PARENT_WORKTREE
+      );
+      expect(result.success).toBe(true);
+      expect(result.alreadyUpToDate).toBe(true);
+    }, 60_000);
     test("detects merge conflicts and aborts merge", async () => {
       const mergeService = await resetWorktree();

package/src/modules/git-workspace/__tests__/pr-manager.test.ts ADDED Viewed

@@ -0,0 +1,80 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { PrManager } from "../pr-manager";
+import type { PrManagerOptions, DraftPrOptions } from "../pr-manager";
+import { GitWorkspaceError } from "@aad/shared/errors";
+describe("PrManager", () => {
+  let options: PrManagerOptions;
+  beforeEach(() => {
+    options = {
+      repoRoot: process.cwd(),
+    };
+  });
+  test("should create instance", () => {
+    const manager = new PrManager(options);
+    expect(manager).toBeDefined();
+  });
+  test("should check gh installation", async () => {
+    const manager = new PrManager(options);
+    const installed = await manager.checkGhInstalled();
+    // May be true or false depending on environment
+    expect(typeof installed).toBe("boolean");
+  });
+  test("should throw error if gh not installed when creating draft PR", async () => {
+    const manager = new PrManager(options);
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+    const draftOptions: DraftPrOptions = {
+      title: "Test PR",
+      body: "Test body",
+      baseBranch: "main",
+      headBranch: "feature/test",
+    };
+    await expect(manager.createDraftPr(draftOptions)).rejects.toThrow(GitWorkspaceError);
+  });
+  test("should throw error if gh not installed when marking PR ready", async () => {
+    const manager = new PrManager(options);
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+    await expect(manager.markPrReady(123)).rejects.toThrow(GitWorkspaceError);
+  });
+  test("should return null for getPrInfo if gh not installed", async () => {
+    const manager = new PrManager(options);
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+    const result = await manager.getPrInfo(123);
+    expect(result).toBeNull();
+  });
+  test("should return null for findPrByBranch if gh not installed", async () => {
+    const manager = new PrManager(options);
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+    const result = await manager.findPrByBranch("feature/test");
+    expect(result).toBeNull();
+  });
+  test("should throw error if gh not installed when closing PR", async () => {
+    const manager = new PrManager(options);
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+    await expect(manager.closePr(123)).rejects.toThrow(GitWorkspaceError);
+  });
+});