@trentapps/manager-protocol 1.1.2 → 1.2.0

package/dist/engine/TaskManager.js

@@ -1,70 +1,46 @@
 /**
  * Enterprise Agent Supervisor - Task Manager
  *
- * Manages project tasks using GitHub Issues via the `gh` CLI.
+ * Manages project tasks using GitHub Issues via the Octokit API.
  * Tasks are stored as GitHub Issues, providing persistence and visibility.
  *
  * Features:
  * - Auto-detects repo from current directory if not specified
  * - Creates priority/status labels automatically
  * - Caches repo detection for performance
- * - Full GitHub Issues integration
+ * - Full GitHub Issues integration via Octokit
  */
-import { exec } from 'child_process';
-import { promisify } from 'util';
 import { auditLogger } from './AuditLogger.js';
-import { escapeForShell } from '../utils/shell.js';
-const execAsync = promisify(exec);
+import { gitHubClient } from './GitHubClient.js';
 export class TaskManager {
     priorityPrefix;
     statusPrefix;
     cachedRepo = null;
     initializedLabels = new Set();
-    ghVerified = false;
+    client;
     constructor(options = {}) {
         this.priorityPrefix = options.priorityLabelPrefix || 'priority:';
         this.statusPrefix = options.statusLabelPrefix || 'status:';
+        this.client = gitHubClient;
     }
     /**
-     * Verify gh CLI is installed and authenticated
+     * Verify GitHub API authentication
      */
     async verifyGh() {
-        if (this.ghVerified)
-            return { ok: true };
-        try {
-            const { stdout } = await execAsync('gh auth status --json user 2>&1 || gh auth status');
-            this.ghVerified = true;
-            // Try to extract user
-            try {
-                const status = JSON.parse(stdout);
-                return { ok: true, user: status.user };
-            }
-            catch {
-                return { ok: true };
-            }
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: 'gh CLI not authenticated. Run: gh auth login'
-            };
-        }
+        return this.client.verifyAuth();
     }
     /**
-     * Get the current repo from git remote or gh CLI
+     * Get the current repo from git remote
      */
     async getCurrentRepo() {
         if (this.cachedRepo)
             return this.cachedRepo;
-        try {
-            // Try to get repo from current directory
-            const { stdout } = await execAsync('gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null');
-            this.cachedRepo = stdout.trim();
+        const repo = await this.client.getCurrentRepo();
+        if (repo) {
+            this.cachedRepo = `${repo.owner}/${repo.repo}`;
             return this.cachedRepo;
         }
-        catch {
-            return null;
-        }
+        return null;
     }
     /**
      * Resolve project name - use provided or auto-detect
@@ -79,45 +55,21 @@ export class TaskManager {
             'Either provide projectName or run from within a git repository.');
     }
     /**
-     * Execute a gh command and return parsed JSON output
+     * Parse repo string into owner/repo components
      */
-    async execGh(command) {
-        try {
-            const { stdout } = await execAsync(`gh ${command}`, {
-                maxBuffer: 10 * 1024 * 1024
-            });
-            return JSON.parse(stdout || '[]');
-        }
-        catch (error) {
-            if (error.stdout === '' || error.stdout === '[]') {
-                return [];
-            }
-            // Parse error message for better feedback
-            const errMsg = error.stderr || error.message || 'Unknown error';
-            if (errMsg.includes('Could not resolve to a Repository')) {
-                throw new Error(`Repository not found. Check the repo name format (owner/repo).`);
-            }
-            if (errMsg.includes('HTTP 404')) {
-                throw new Error(`Not found - check repository access permissions.`);
-            }
-            if (errMsg.includes('HTTP 401') || errMsg.includes('authentication')) {
-                throw new Error(`Authentication failed. Run: gh auth login`);
-            }
-            throw new Error(`gh command failed: ${errMsg}`);
-        }
+    parseRepo(repoString) {
+        return this.client.parseRepo(repoString);
     }
     /**
-     * Execute a gh command without JSON output
+     * Ensure a task exists before operating on it
+     * @throws Error if task is not found
      */
-    async execGhRaw(command) {
-        try {
-            const { stdout } = await execAsync(`gh ${command}`);
-            return stdout.trim();
-        }
-        catch (error) {
-            const errMsg = error.stderr || error.message || 'Unknown error';
-            throw new Error(`gh command failed: ${errMsg}`);
+    async ensureTaskExists(repo, taskId) {
+        const task = await this.getTask(repo, taskId);
+        if (!task) {
+            throw new Error(`Task #${taskId} not found in ${repo}`);
         }
+        return task;
     }
     /**
      * Ensure a label exists in the repo, create if not
@@ -137,29 +89,29 @@ export class TaskManager {
             [`${this.statusPrefix}cancelled`]: '808080',
             'needs-approval': 'FF6B6B',
         };
+        const { owner, repo: repoName } = this.parseRepo(repo);
         try {
             // Check if label exists
-            await this.execGh(`label view "${labelName}" --repo "${repo}" --json name`);
+            const existing = await this.client.getLabel(owner, repoName, labelName);
+            if (existing) {
+                this.initializedLabels.add(cacheKey);
+                return;
+            }
+            // Label doesn't exist, create it
+            const color = labelColors[labelName] || '666666';
+            const description = labelName.startsWith(this.priorityPrefix)
+                ? `Priority: ${labelName.replace(this.priorityPrefix, '')}`
+                : labelName.startsWith(this.statusPrefix)
+                    ? `Status: ${labelName.replace(this.statusPrefix, '')}`
+                    : labelName === 'needs-approval'
+                        ? 'Significant change requiring approval before implementation'
+                        : '';
+            await this.client.createLabel(owner, repoName, labelName, color, description || undefined);
             this.initializedLabels.add(cacheKey);
         }
         catch {
-            // Label doesn't exist, create it
-            try {
-                const color = labelColors[labelName] || '666666';
-                const description = labelName.startsWith(this.priorityPrefix)
-                    ? `Priority: ${labelName.replace(this.priorityPrefix, '')}`
-                    : labelName.startsWith(this.statusPrefix)
-                        ? `Status: ${labelName.replace(this.statusPrefix, '')}`
-                        : labelName === 'needs-approval'
-                            ? 'Significant change requiring approval before implementation'
-                            : '';
-                await this.execGhRaw(`label create "${labelName}" --repo "${repo}" --color "${color}" --description "${description}" --force`);
-                this.initializedLabels.add(cacheKey);
-            }
-            catch {
-                // Label creation failed, might be permissions - continue anyway
-                this.initializedLabels.add(cacheKey);
-            }
+            // Label creation failed, might be permissions - continue anyway
+            this.initializedLabels.add(cacheKey);
         }
     }
     /**
@@ -171,7 +123,7 @@ export class TaskManager {
         const priorityLabel = labels.find(l => l.startsWith(this.priorityPrefix));
         const priority = (priorityLabel?.replace(this.priorityPrefix, '') || 'medium');
         // Extract status from labels or state
-        let status = issue.state === 'OPEN' ? 'pending' : 'completed';
+        let status = issue.state === 'open' ? 'pending' : 'completed';
         const statusLabel = labels.find(l => l.startsWith(this.statusPrefix));
         if (statusLabel) {
             const labelStatus = statusLabel.replace(this.statusPrefix, '');
@@ -179,7 +131,7 @@ export class TaskManager {
                 status = labelStatus;
             }
         }
-        else if (issue.state === 'OPEN') {
+        else if (issue.state === 'open') {
             if (labels.includes('in-progress') || labels.includes('wip')) {
                 status = 'in_progress';
             }
@@ -196,17 +148,17 @@ export class TaskManager {
             description: issue.body || undefined,
             status,
             priority,
-            assignee: issue.assignees[0]?.login,
+            assignee: issue.assignees?.[0]?.login,
             labels: cleanLabels.length > 0 ? cleanLabels : undefined,
             dueDate: issue.milestone?.title,
-            createdAt: issue.createdAt,
-            updatedAt: issue.updatedAt,
-            completedAt: issue.closedAt || undefined,
-            metadata: { url: issue.url }
+            createdAt: issue.created_at,
+            updatedAt: issue.updated_at,
+            completedAt: issue.closed_at || undefined,
+            metadata: { url: issue.html_url }
         };
     }
     /**
-     * Build labels array for gh command
+     * Build labels array for issue
      */
     buildLabels(priority, status, labels) {
         const allLabels = [];
@@ -229,6 +181,7 @@ export class TaskManager {
      */
     async createTask(params) {
         const repo = await this.resolveRepo(params.projectName);
+        const { owner, repo: repoName } = this.parseRepo(repo);
         const allLabels = this.buildLabels(params.priority, 'pending', params.labels);
         // Add needs-approval label if flagged
         if (params.needsApproval) {
@@ -240,30 +193,29 @@ export class TaskManager {
                 await this.ensureLabel(repo, label);
             }
         }
-        // Build the gh issue create command
-        let cmd = `issue create --repo "${repo}" --title ${escapeForShell(params.title)}`;
-        if (params.description) {
-            cmd += ` --body ${escapeForShell(params.description)}`;
-        }
-        if (allLabels.length > 0) {
-            cmd += ` --label ${escapeForShell(allLabels.join(','))}`;
-        }
+        // Handle @me assignee - need to resolve to actual username
+        let assignees;
         if (params.assignee) {
-            // Handle @me specially
-            const assignee = params.assignee === '@me' ? '@me' : params.assignee;
-            cmd += ` --assignee ${escapeForShell(assignee)}`;
-        }
-        // Create the issue - gh issue create returns the URL, not JSON
-        const issueUrl = await this.execGhRaw(cmd);
-        // Extract issue number from URL (e.g., https://github.com/owner/repo/issues/123)
-        const issueNumberMatch = issueUrl.match(/\/issues\/(\d+)/);
-        if (!issueNumberMatch) {
-            throw new Error(`Failed to parse issue number from: ${issueUrl}`);
+            if (params.assignee === '@me') {
+                const auth = await this.client.verifyAuth();
+                if (auth.ok && auth.user) {
+                    assignees = [auth.user];
+                }
+            }
+            else {
+                assignees = [params.assignee];
+            }
         }
-        const issueNumber = issueNumberMatch[1];
-        // Fetch the full issue details
-        const result = await this.execGh(`issue view ${issueNumber} --repo "${repo}" --json number,title,body,state,labels,assignees,createdAt,updatedAt,closedAt,url`);
-        const task = this.issueToTask(result, repo);
+        // Create the issue
+        const issue = await this.client.createIssue({
+            owner,
+            repo: repoName,
+            title: params.title,
+            body: params.description,
+            labels: allLabels.length > 0 ? allLabels : undefined,
+            assignees,
+        });
+        const task = this.issueToTask(issue, repo);
         await auditLogger.log({
             eventType: 'action_executed',
             action: 'task_created',
@@ -273,7 +225,7 @@ export class TaskManager {
                 projectName: repo,
                 title: params.title,
                 priority: task.priority,
-                ghIssueUrl: result.url
+                ghIssueUrl: issue.html_url
             }
         });
         return task;
@@ -282,49 +234,58 @@ export class TaskManager {
      * Get all tasks for a project
      */
     async getTasksByProject(projectName, filter) {
-        const repo = await this.resolveRepo(projectName);
-        let stateFilter = 'all';
-        if (filter?.status === 'completed' || filter?.status === 'cancelled') {
-            stateFilter = 'closed';
-        }
-        else if (filter?.status) {
-            // Status is pending, in_progress, or blocked - use open issues
-            stateFilter = 'open';
-        }
-        let cmd = `issue list --repo "${repo}" --state ${stateFilter} --json number,title,body,state,labels,assignees,createdAt,updatedAt,closedAt,url --limit 100`;
-        const labelFilters = [];
-        if (filter?.priority) {
-            labelFilters.push(`${this.priorityPrefix}${filter.priority}`);
-        }
-        if (filter?.status && !['pending', 'completed'].includes(filter.status)) {
-            labelFilters.push(`${this.statusPrefix}${filter.status}`);
-        }
-        if (filter?.labels) {
-            labelFilters.push(...filter.labels);
-        }
-        if (labelFilters.length > 0) {
-            cmd += ` --label ${escapeForShell(labelFilters.join(','))}`;
-        }
-        if (filter?.assignee) {
-            cmd += ` --assignee ${escapeForShell(filter.assignee)}`;
+        try {
+            const repo = await this.resolveRepo(projectName);
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            let stateFilter = 'all';
+            if (filter?.status === 'completed' || filter?.status === 'cancelled') {
+                stateFilter = 'closed';
+            }
+            else if (filter?.status) {
+                // Status is pending, in_progress, or blocked - use open issues
+                stateFilter = 'open';
+            }
+            // Build labels filter
+            const labelFilters = [];
+            if (filter?.priority) {
+                labelFilters.push(`${this.priorityPrefix}${filter.priority}`);
+            }
+            if (filter?.status && !['pending', 'completed'].includes(filter.status)) {
+                labelFilters.push(`${this.statusPrefix}${filter.status}`);
+            }
+            if (filter?.labels) {
+                labelFilters.push(...filter.labels);
+            }
+            const issues = await this.client.listIssues({
+                owner,
+                repo: repoName,
+                state: stateFilter,
+                labels: labelFilters.length > 0 ? labelFilters.join(',') : undefined,
+                assignee: filter?.assignee,
+                per_page: 100,
+            });
+            let tasks = issues.map(issue => this.issueToTask(issue, repo));
+            if (filter?.status) {
+                tasks = tasks.filter(t => t.status === filter.status);
+            }
+            const priorityOrder = {
+                critical: 0,
+                high: 1,
+                medium: 2,
+                low: 3
+            };
+            return tasks.sort((a, b) => {
+                const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+                if (priorityDiff !== 0)
+                    return priorityDiff;
+                return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+            });
         }
-        const issues = await this.execGh(cmd);
-        let tasks = issues.map(issue => this.issueToTask(issue, repo));
-        if (filter?.status) {
-            tasks = tasks.filter(t => t.status === filter.status);
+        catch (error) {
+            // Return empty array for 404 errors (repo doesn't exist or no access)
+            // This maintains backward compatibility with the gh CLI version
+            return [];
         }
-        const priorityOrder = {
-            critical: 0,
-            high: 1,
-            medium: 2,
-            low: 3
-        };
-        return tasks.sort((a, b) => {
-            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
-            if (priorityDiff !== 0)
-                return priorityDiff;
-            return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
-        });
     }
     /**
      * Get pending tasks for a project
@@ -344,7 +305,8 @@ export class TaskManager {
     async getTask(projectName, taskId) {
         try {
             const repo = await this.resolveRepo(projectName);
-            const issue = await this.execGh(`issue view ${taskId} --repo "${repo}" --json number,title,body,state,labels,assignees,createdAt,updatedAt,closedAt,url`);
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            const issue = await this.client.getIssue(owner, repoName, parseInt(taskId, 10));
             return this.issueToTask(issue, repo);
         }
         catch {
@@ -357,18 +319,21 @@ export class TaskManager {
     async updateTask(projectName, taskId, updates) {
         try {
             const repo = await this.resolveRepo(projectName);
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            const issueNumber = parseInt(taskId, 10);
             // Verify task exists before attempting update
-            const existingTask = await this.getTask(repo, taskId);
-            if (!existingTask) {
-                console.error(`[TaskManager] Cannot update task ${taskId}: task not found in ${repo}`);
-                return null;
-            }
-            let cmd = `issue edit ${taskId} --repo "${repo}"`;
+            const existingTask = await this.ensureTaskExists(repo, taskId);
+            // Build update params
+            const updateParams = {
+                owner,
+                repo: repoName,
+                issue_number: issueNumber,
+            };
             if (updates.title) {
-                cmd += ` --title ${escapeForShell(updates.title)}`;
+                updateParams.title = updates.title;
             }
             if (updates.description !== undefined) {
-                cmd += ` --body ${escapeForShell(updates.description || '')}`;
+                updateParams.body = updates.description || '';
             }
             if (updates.priority || updates.labels) {
                 const newLabels = this.buildLabels(updates.priority || existingTask.priority, updates.status || existingTask.status, updates.labels || existingTask.labels);
@@ -377,14 +342,13 @@ export class TaskManager {
                         await this.ensureLabel(repo, label);
                     }
                 }
-                if (newLabels.length > 0) {
-                    cmd += ` --add-label ${escapeForShell(newLabels.join(','))}`;
-                }
+                // Get existing labels and merge with new ones
+                updateParams.labels = newLabels;
             }
             if (updates.assignee) {
-                cmd += ` --add-assignee ${escapeForShell(updates.assignee)}`;
+                updateParams.assignees = [updates.assignee];
             }
-            await this.execGhRaw(cmd);
+            await this.client.updateIssue(updateParams);
             // Add comment if provided (with optional commit links)
             if (updates.comment || updates.commits?.length) {
                 await this.addComment(repo, taskId, updates.comment, updates.commits);
@@ -423,6 +387,10 @@ export class TaskManager {
     async addComment(projectName, taskId, comment, commits) {
         try {
             const repo = await this.resolveRepo(projectName);
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            const issueNumber = parseInt(taskId, 10);
+            // Verify task exists before attempting to add comment
+            await this.ensureTaskExists(repo, taskId);
             // Build comment body
             let body = '';
             if (comment) {
@@ -442,7 +410,7 @@ export class TaskManager {
             if (!body) {
                 return false;
             }
-            await this.execGhRaw(`issue comment ${taskId} --repo "${repo}" --body ${escapeForShell(body)}`);
+            await this.client.addComment(owner, repoName, issueNumber, body);
             await auditLogger.log({
                 eventType: 'action_executed',
                 action: 'task_comment_added',
@@ -466,6 +434,8 @@ export class TaskManager {
      */
     async closeWithComment(projectName, taskId, resolution, commits) {
         const repo = await this.resolveRepo(projectName);
+        // Verify task exists before attempting to close
+        await this.ensureTaskExists(repo, taskId);
         // Add the resolution comment
         await this.addComment(repo, taskId, `**Resolution:** ${resolution}`, commits);
         // Close the issue
@@ -477,28 +447,30 @@ export class TaskManager {
     async updateTaskStatus(projectName, taskId, status) {
         try {
             const repo = await this.resolveRepo(projectName);
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            const issueNumber = parseInt(taskId, 10);
             // Close or reopen based on status
             if (status === 'completed' || status === 'cancelled') {
-                const reason = status === 'cancelled' ? ' --reason "not planned"' : '';
-                await this.execGhRaw(`issue close ${taskId} --repo "${repo}"${reason}`);
+                const reason = status === 'cancelled' ? 'not_planned' : 'completed';
+                await this.client.closeIssue(owner, repoName, issueNumber, reason);
             }
             else {
                 const task = await this.getTask(repo, taskId);
                 if (task?.status === 'completed' || task?.status === 'cancelled') {
-                    await this.execGhRaw(`issue reopen ${taskId} --repo "${repo}"`);
+                    await this.client.reopenIssue(owner, repoName, issueNumber);
                 }
             }
             // Update status label
             if (status !== 'pending' && status !== 'completed') {
                 const statusLabel = `${this.statusPrefix}${status}`;
                 await this.ensureLabel(repo, statusLabel);
-                await this.execGhRaw(`issue edit ${escapeForShell(taskId)} --repo ${escapeForShell(repo)} --add-label ${escapeForShell(statusLabel)}`);
+                await this.client.addLabels(owner, repoName, issueNumber, [statusLabel]);
             }
             // Remove old status labels
             const oldStatuses = ['in_progress', 'blocked', 'cancelled'].filter(s => s !== status);
             for (const oldStatus of oldStatuses) {
                 try {
-                    await this.execGhRaw(`issue edit ${escapeForShell(taskId)} --repo ${escapeForShell(repo)} --remove-label ${escapeForShell(this.statusPrefix + oldStatus)}`);
+                    await this.client.removeLabel(owner, repoName, issueNumber, `${this.statusPrefix}${oldStatus}`);
                 }
                 catch {
                     // Ignore - label might not exist
@@ -527,8 +499,12 @@ export class TaskManager {
      */
     async blockTask(projectName, taskId, reason) {
         const repo = await this.resolveRepo(projectName);
+        const { owner, repo: repoName } = this.parseRepo(repo);
+        const issueNumber = parseInt(taskId, 10);
+        // Verify task exists before attempting to block
+        await this.ensureTaskExists(repo, taskId);
         if (reason) {
-            await this.execGhRaw(`issue comment ${taskId} --repo "${repo}" --body ${escapeForShell(`Blocked: ${reason}`)}`);
+            await this.client.addComment(owner, repoName, issueNumber, `Blocked: ${reason}`);
         }
         return this.updateTaskStatus(repo, taskId, 'blocked');
     }
@@ -538,7 +514,9 @@ export class TaskManager {
     async deleteTask(projectName, taskId) {
         try {
             const repo = await this.resolveRepo(projectName);
-            await this.execGhRaw(`issue close ${taskId} --repo "${repo}" --reason "not planned"`);
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            const issueNumber = parseInt(taskId, 10);
+            await this.client.closeIssue(owner, repoName, issueNumber, 'not_planned');
             await auditLogger.log({
                 eventType: 'action_executed',
                 action: 'task_deleted',
@@ -556,13 +534,14 @@ export class TaskManager {
      */
     async listProjects() {
         try {
-            const repos = await this.execGh('repo list --limit 20 --json nameWithOwner');
+            const repos = await this.client.listRepos(20);
             const projects = [];
             const results = await Promise.allSettled(repos.slice(0, 10).map(async (repo) => {
                 try {
+                    const { owner, repo: repoName } = this.parseRepo(repo.nameWithOwner);
                     const [openIssues, closedIssues] = await Promise.all([
-                        this.execGh(`issue list --repo "${repo.nameWithOwner}" --state open --json number,labels --limit 100`),
-                        this.execGh(`issue list --repo "${repo.nameWithOwner}" --state closed --json number --limit 100`)
+                        this.client.listIssues({ owner, repo: repoName, state: 'open', per_page: 100 }),
+                        this.client.listIssues({ owner, repo: repoName, state: 'closed', per_page: 100 })
                     ]);
                     const inProgressCount = openIssues.filter(i => i.labels?.some(l => l.name === `${this.statusPrefix}in_progress` ||
                         l.name === 'in-progress' ||
@@ -596,11 +575,11 @@ export class TaskManager {
     async getProjectStats(projectName) {
         try {
             const repo = await this.resolveRepo(projectName);
-            // Fetch only minimal fields needed for stats (labels, closedAt)
-            // Increased limit to 500 to capture more tasks for accurate stats
+            const { owner, repo: repoName } = this.parseRepo(repo);
+            // Fetch issues for stats
             const [openIssues, closedIssues] = await Promise.all([
-                this.execGh(`issue list --repo "${repo}" --state open --json labels --limit 500`),
-                this.execGh(`issue list --repo "${repo}" --state closed --json labels,closedAt --limit 500`)
+                this.client.listIssues({ owner, repo: repoName, state: 'open', per_page: 100 }),
+                this.client.listIssues({ owner, repo: repoName, state: 'closed', per_page: 100 })
             ]);
             const byStatus = {};
             const byPriority = {};
@@ -626,7 +605,7 @@ export class TaskManager {
                 const priority = labels.find(l => l.startsWith(this.priorityPrefix))?.replace(this.priorityPrefix, '') || 'medium';
                 byPriority[priority] = (byPriority[priority] || 0) + 1;
                 // Count completed this week
-                if (issue.closedAt && new Date(issue.closedAt) >= oneWeekAgo) {
+                if (issue.closed_at && new Date(issue.closed_at) >= oneWeekAgo) {
                     completedThisWeek++;
                 }
             }
@@ -649,13 +628,13 @@ export class TaskManager {
      */
     async searchTasks(query, projectName) {
         try {
-            let cmd = `issue list --search ${escapeForShell(query)} --state all --json number,title,body,state,labels,assignees,createdAt,updatedAt,closedAt,url --limit 50`;
+            let searchQuery = query;
             if (projectName) {
-                cmd += ` --repo ${escapeForShell(projectName)}`;
+                searchQuery = `repo:${projectName} ${query}`;
             }
-            const issues = await this.execGh(cmd);
+            const issues = await this.client.searchIssues({ query: searchQuery, per_page: 50 });
             return issues.map(issue => {
-                const repoMatch = issue.url.match(/github\.com\/([^/]+\/[^/]+)\//);
+                const repoMatch = issue.html_url.match(/github\.com\/([^/]+\/[^/]+)\//);
                 const repo = repoMatch ? repoMatch[1] : projectName || 'unknown';
                 return this.issueToTask(issue, repo);
             });
@@ -669,7 +648,13 @@ export class TaskManager {
      */
     async clearCompletedTasks(projectName) {
         const repo = await this.resolveRepo(projectName);
-        const closedIssues = await this.execGh(`issue list --repo "${repo}" --state closed --json number --limit 100`);
+        const { owner, repo: repoName } = this.parseRepo(repo);
+        const closedIssues = await this.client.listIssues({
+            owner,
+            repo: repoName,
+            state: 'closed',
+            per_page: 100
+        });
         return closedIssues.length;
     }
 }