claude-autopm 1.17.0 → 1.20.0

package/lib/providers/azure/index.js

@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Azure DevOps Provider Implementation
- * Maps ClaudeAutoPM concepts to Azure DevOps Work Items
- */
-
-const ProviderInterface = require('../interface');
-
-class AzureProvider extends ProviderInterface {
-  constructor(client) {
-    super(client);
-  }
-
-  /**
-   * Create Epic Work Item
-   */
-  async createEpic(prd) {
-    const workItem = await this.client.createWorkItem({
-      type: 'Epic',
-      fields: {
-        'System.Title': prd.title,
-        'System.Description': prd.description || '',
-        'System.Tags': 'ClaudeAutoPM;Epic'
-      }
-    });
-
-    return {
-      id: workItem.id,
-      title: workItem.fields['System.Title'],
-      url: workItem.url || this._getWorkItemUrl(workItem.id),
-      provider: 'azure',
-      workItemType: 'Epic'
-    };
-  }
-
-  /**
-   * Create User Story Work Item linked to Epic
-   */
-  async createUserStory(epic, story) {
-    const fields = {
-      'System.Title': story.title,
-      'System.Description': story.description || '',
-      'System.Parent': epic.id,
-      'System.Tags': 'ClaudeAutoPM;UserStory'
-    };
-
-    // Add acceptance criteria if present
-    if (story.acceptanceCriteria && story.acceptanceCriteria.length > 0) {
-      fields['Microsoft.VSTS.Common.AcceptanceCriteria'] =
-        '<ul>' + story.acceptanceCriteria.map(c => `<li>${c}</li>`).join('') + '</ul>';
-    }
-
-    const workItem = await this.client.createWorkItem({
-      type: 'User Story',
-      fields: fields
-    });
-
-    return {
-      id: workItem.id,
-      title: workItem.fields['System.Title'],
-      url: workItem.url || this._getWorkItemUrl(workItem.id),
-      parentId: epic.id,
-      workItemType: 'User Story'
-    };
-  }
-
-  /**
-   * Create Task Work Item linked to User Story
-   */
-  async createTask(parent, task) {
-    const fields = {
-      'System.Title': task.title,
-      'System.Description': task.description || '',
-      'System.Parent': parent.id,
-      'System.Tags': 'ClaudeAutoPM;Task'
-    };
-
-    // Add remaining work if specified
-    if (task.remainingWork) {
-      fields['Microsoft.VSTS.Scheduling.RemainingWork'] = task.remainingWork;
-    }
-
-    // Add assigned to if specified
-    if (task.assignedTo) {
-      fields['System.AssignedTo'] = task.assignedTo;
-    }
-
-    const workItem = await this.client.createWorkItem({
-      type: 'Task',
-      fields: fields
-    });
-
-    return {
-      id: workItem.id,
-      title: workItem.fields['System.Title'],
-      url: workItem.url || this._getWorkItemUrl(workItem.id),
-      parentId: parent.id,
-      workItemType: 'Task'
-    };
-  }
-
-  /**
-   * Link work items in parent-child hierarchy
-   */
-  async linkHierarchy(parent, child) {
-    // Azure DevOps uses the System.Parent field for hierarchy
-    await this.client.updateWorkItem({
-      id: child.id,
-      fields: {
-        'System.Parent': parent.id
-      }
-    });
-  }
-
-  /**
-   * Sync complete Epic structure to Azure DevOps
-   */
-  async syncEpic(epicData) {
-    const results = {
-      epic: null,
-      userStories: [],
-      hierarchy: {}
-    };
-
-    try {
-      // Create Epic
-      results.epic = await this.createEpic({
-        title: epicData.title,
-        description: epicData.description
-      });
-
-      // Create User Stories with Tasks
-      if (epicData.userStories && epicData.userStories.length > 0) {
-        for (const story of epicData.userStories) {
-          const createdStory = await this.createUserStory(results.epic, story);
-
-          // Track tasks for this story
-          const storyTasks = [];
-
-          // Create tasks for this user story
-          if (story.tasks && story.tasks.length > 0) {
-            for (const task of story.tasks) {
-              const createdTask = await this.createTask(createdStory, task);
-              storyTasks.push(createdTask);
-            }
-          }
-
-          results.userStories.push({
-            ...createdStory,
-            tasks: storyTasks
-          });
-        }
-      }
-
-      // Build hierarchy response
-      results.hierarchy = {
-        epic: {
-          id: results.epic.id,
-          title: results.epic.title,
-          url: results.epic.url
-        },
-        userStories: results.userStories.map(story => ({
-          id: story.id,
-          title: story.title,
-          url: story.url,
-          tasks: story.tasks.map(task => ({
-            id: task.id,
-            title: task.title,
-            url: task.url
-          }))
-        }))
-      };
-
-      return results;
-
-    } catch (error) {
-      throw new Error(`Failed to sync epic: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get work item by ID
-   */
-  async getWorkItem(id) {
-    const workItem = await this.client.getWorkItem({ id });
-    return {
-      id: workItem.id,
-      title: workItem.fields['System.Title'],
-      description: workItem.fields['System.Description'],
-      state: workItem.fields['System.State'],
-      workItemType: workItem.fields['System.WorkItemType'],
-      parent: workItem.fields['System.Parent']
-    };
-  }
-
-  /**
-   * Update work item
-   */
-  async updateWorkItem(id, updates) {
-    const fields = {};
-
-    // Map common updates to Azure fields
-    if (updates.title) {
-      fields['System.Title'] = updates.title;
-    }
-    if (updates.description) {
-      fields['System.Description'] = updates.description;
-    }
-    if (updates.state) {
-      fields['System.State'] = updates.state;
-    }
-    if (updates.assignedTo) {
-      fields['System.AssignedTo'] = updates.assignedTo;
-    }
-
-    return await this.client.updateWorkItem({
-      id: id,
-      fields: fields
-    });
-  }
-
-  /**
-   * Get work item URL
-   */
-  _getWorkItemUrl(id) {
-    // This would need to be configured with actual org/project
-    const org = process.env.AZURE_DEVOPS_ORG || 'organization';
-    const project = process.env.AZURE_DEVOPS_PROJECT || 'project';
-    return `https://dev.azure.com/${org}/${project}/_workitems/edit/${id}`;
-  }
-}
-
-module.exports = AzureProvider;

package/lib/providers/factory.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Provider Factory
- * Creates appropriate provider based on configuration
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const GitHubProvider = require('./github');
-const AzureProvider = require('./azure');
-
-class ProviderFactory {
-  /**
-   * Create provider instance
-   */
-  static create(providerName, client) {
-    switch (providerName) {
-      case 'github':
-        return new GitHubProvider(client);
-
-      case 'azure':
-        return new AzureProvider(client);
-
-      default:
-        throw new Error(`Unknown provider: ${providerName}`);
-    }
-  }
-
-  /**
-   * Auto-detect provider from configuration
-   */
-  static autoDetect() {
-    const configPath = path.join(process.cwd(), '.claude', 'config.json');
-
-    if (!fs.existsSync(configPath)) {
-      // Default to GitHub if no config
-      return new GitHubProvider(this._getDefaultClient('github'));
-    }
-
-    try {
-      const config = fs.readJsonSync(configPath);
-      const provider = config.provider || 'github';
-      const client = this._getDefaultClient(provider, config);
-
-      return this.create(provider, client);
-    } catch (error) {
-      console.error(`Error loading config: ${error.message}`);
-      return new GitHubProvider(this._getDefaultClient('github'));
-    }
-  }
-
-  /**
-   * Get default client for provider
-   */
-  static _getDefaultClient(provider, config = {}) {
-    if (provider === 'azure') {
-      // Return Azure DevOps client
-      const azureConfig = config.providers?.azure || {};
-      return require('../../lib/azure/client').createClient({
-        organization: azureConfig.organization || process.env.AZURE_DEVOPS_ORG,
-        project: azureConfig.project || process.env.AZURE_DEVOPS_PROJECT,
-        token: process.env.AZURE_DEVOPS_PAT
-      });
-    } else {
-      // Return GitHub client
-      const githubConfig = config.providers?.github || {};
-      return {
-        createIssue: async (data) => {
-          // This would use the actual GitHub API
-          console.log('Creating GitHub issue:', data);
-          return { number: Math.floor(Math.random() * 1000), ...data };
-        },
-        updateIssue: async (number, data) => {
-          console.log(`Updating GitHub issue #${number}:`, data);
-          return { number, ...data };
-        },
-        getIssue: async (number) => {
-          console.log(`Getting GitHub issue #${number}`);
-          return { number, body: 'Issue body', state: 'open' };
-        }
-      };
-    }
-  }
-}
-
-module.exports = ProviderFactory;

package/lib/providers/github/index.js

@@ -1,204 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * GitHub Provider Implementation
- * Maps ClaudeAutoPM concepts to GitHub Issues
- */
-
-const ProviderInterface = require('../interface');
-
-class GitHubProvider extends ProviderInterface {
-  constructor(client) {
-    super(client);
-  }
-
-  /**
-   * Create Epic as a GitHub Issue with 'epic' label
-   */
-  async createEpic(prd) {
-    const issue = await this.client.createIssue({
-      title: `Epic: ${prd.title}`,
-      body: this._formatEpicBody(prd),
-      labels: ['epic']
-    });
-
-    return {
-      number: issue.number,
-      title: issue.title,
-      url: issue.html_url,
-      provider: 'github'
-    };
-  }
-
-  /**
-   * Create Task as GitHub Issue linked to Epic
-   */
-  async createTask(epic, task) {
-    const body = `${task.description || task.title}\n\nPart of #${epic.number}`;
-
-    const issue = await this.client.createIssue({
-      title: task.title,
-      body: body,
-      labels: ['task']
-    });
-
-    return {
-      number: issue.number,
-      title: issue.title,
-      url: issue.html_url,
-      epicNumber: epic.number
-    };
-  }
-
-  /**
-   * GitHub doesn't have User Stories, so tasks link directly to Epic
-   */
-  async createUserStory(epic, story) {
-    // In GitHub, we treat user stories as labeled issues
-    const body = this._formatStoryBody(story, epic);
-
-    const issue = await this.client.createIssue({
-      title: story.title,
-      body: body,
-      labels: ['user-story', 'epic']
-    });
-
-    return {
-      number: issue.number,
-      title: issue.title,
-      url: issue.html_url,
-      epicNumber: epic.number
-    };
-  }
-
-  /**
-   * Link hierarchy via issue references in GitHub
-   */
-  async linkHierarchy(parent, child) {
-    // GitHub uses issue references in body text
-    const currentBody = await this.client.getIssue(child.number);
-    const updatedBody = `${currentBody.body}\n\nParent: #${parent.number}`;
-
-    await this.client.updateIssue(child.number, {
-      body: updatedBody
-    });
-  }
-
-  /**
-   * Sync complete Epic structure to GitHub
-   */
-  async syncEpic(epicData) {
-    const results = {
-      epic: null,
-      userStories: [],
-      tasks: [],
-      hierarchy: {}
-    };
-
-    // Create Epic
-    results.epic = await this.createEpic({
-      title: epicData.title,
-      description: epicData.description
-    });
-
-    // Create User Stories and Tasks
-    if (epicData.userStories && epicData.userStories.length > 0) {
-      for (const story of epicData.userStories) {
-        const createdStory = await this.createUserStory(results.epic, story);
-        results.userStories.push(createdStory);
-
-        // Create tasks for this story
-        if (story.tasks && story.tasks.length > 0) {
-          const storyTasks = [];
-          for (const task of story.tasks) {
-            const createdTask = await this.createTask(createdStory, task);
-            storyTasks.push(createdTask);
-          }
-          createdStory.tasks = storyTasks;
-        }
-      }
-    } else if (epicData.issues) {
-      // Direct issues without user stories
-      for (const issue of epicData.issues) {
-        const createdTask = await this.createTask(results.epic, issue);
-        results.tasks.push(createdTask);
-      }
-    }
-
-    // Build hierarchy for response
-    results.hierarchy = {
-      epic: results.epic,
-      userStories: results.userStories.map(story => ({
-        id: story.number,
-        tasks: story.tasks || []
-      }))
-    };
-
-    return results;
-  }
-
-  /**
-   * Get work item (issue) by ID
-   */
-  async getWorkItem(id) {
-    const issue = await this.client.getIssue(id);
-    return {
-      id: issue.number,
-      title: issue.title,
-      body: issue.body,
-      state: issue.state,
-      labels: issue.labels
-    };
-  }
-
-  /**
-   * Update work item (issue)
-   */
-  async updateWorkItem(id, updates) {
-    return await this.client.updateIssue(id, updates);
-  }
-
-  /**
-   * Format Epic body for GitHub
-   */
-  _formatEpicBody(prd) {
-    let body = `# ${prd.title}\n\n`;
-    body += `${prd.description || ''}\n\n`;
-
-    if (prd.userStories && prd.userStories.length > 0) {
-      body += '## User Stories\n\n';
-      prd.userStories.forEach(story => {
-        body += `- [ ] ${story}\n`;
-      });
-      body += '\n';
-    }
-
-    if (prd.acceptanceCriteria && prd.acceptanceCriteria.length > 0) {
-      body += '## Acceptance Criteria\n\n';
-      prd.acceptanceCriteria.forEach(criteria => {
-        body += `- ${criteria}\n`;
-      });
-    }
-
-    return body;
-  }
-
-  /**
-   * Format User Story body
-   */
-  _formatStoryBody(story, epic) {
-    let body = story.description || story.title;
-    body += `\n\nPart of Epic #${epic.number}\n\n`;
-
-    if (story.acceptanceCriteria && story.acceptanceCriteria.length > 0) {
-      body += '## Acceptance Criteria\n\n';
-      story.acceptanceCriteria.forEach(criteria => {
-        body += `- ${criteria}\n`;
-      });
-    }
-
-    return body;
-  }
-}
-
-module.exports = GitHubProvider;

package/lib/providers/interface.js

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Provider Interface - Abstract base class
- * All providers must extend this interface
- */
-
-class ProviderInterface {
-  constructor(client) {
-    if (new.target === ProviderInterface) {
-      throw new TypeError('Cannot instantiate abstract class');
-    }
-    this.client = client;
-  }
-
-  /**
-   * Create an Epic from PRD
-   */
-  async createEpic(prd) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Create a User Story (or equivalent)
-   */
-  async createUserStory(parent, story) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Create a Task
-   */
-  async createTask(parent, task) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Link work items in hierarchy
-   */
-  async linkHierarchy(parent, child) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Sync complete epic structure
-   */
-  async sync(epicData) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Get a work item by ID
-   */
-  async getWorkItem(id) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Update a work item
-   */
-  async updateWorkItem(id, updates) {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Sync an entire epic hierarchy
-   */
-  async syncEpic(epicData) {
-    throw new Error('Not implemented');
-  }
-}
-
-module.exports = ProviderInterface;