@forloop-cc/forloop-opencode-plugin-planner 2.2.1

package/plugins/tools/organization-tools.ts

@@ -0,0 +1,213 @@
+import { tool } from '@opencode-ai/plugin';
+import { ForLoopAPIClient } from '../capabilities/api-client';
+import { validateToken } from '../capabilities/auth';
+
+export function createOrganizationListTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'List organizations you belong to',
+    args: {
+      ownedOnly: tool.schema.boolean()
+        .optional()
+        .default(false)
+        .describe('List only owned organizations'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const orgs = args.ownedOnly
+          ? await client.getOwnedOrganizations()
+          : await client.listOrganizations();
+
+        const lines: string[] = ['🏢 Organizations:', ''];
+
+        if (orgs.length === 0) {
+          return 'No organizations found.';
+        }
+
+        for (const org of orgs) {
+          const role = org.members?.[0]?.role || 'member';
+          const icon = org.type === 'system' ? '🌐' : role === 'owner' ? '👑' : '👤';
+          const tier = org.type === 'system' ? '' : ` (${org.type || 'user'})`;
+
+          lines.push(`${icon} #${org.id} **${org.name}**${tier}`);
+          lines.push(`   Role: ${role}`);
+          if (org.description) {
+            lines.push(`   Description: ${org.description}`);
+          }
+          lines.push('');
+        }
+
+        return lines.join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createOrganizationGetTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Get details of a specific organization',
+    args: {
+      organizationId: tool.schema.number()
+        .describe('Organization ID to retrieve'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const org = await client.getOrganization(args.organizationId);
+        
+        const lines: string[] = [
+          `🏢 Organization #${org.id}`,
+          '',
+          `**Name**: ${org.name}`,
+          `**Type**: ${org.type || 'user'}`,
+        ];
+        
+        if (org.description) {
+          lines.push(`**Description**: ${org.description}`);
+        }
+        
+        if (org.createdAt) {
+          lines.push(`**Created**: ${new Date(org.createdAt).toLocaleDateString()}`);
+        }
+        
+        return lines.join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createOrganizationCreateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Create a new organization (requires Team/Enterprise tier)',
+    args: {
+      name: tool.schema.string()
+        .describe('Organization name'),
+      description: tool.schema.string()
+        .optional()
+        .describe('Organization description'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const profile = await client.getUserProfile();
+        if (!['team', 'enterprise'].includes(profile.tier)) {
+          return '❌ Creating organizations requires Team or Enterprise tier. Contact support to upgrade.';
+        }
+
+        const quotas = await client.getUserQuotas();
+        if (quotas.remaining?.ownedOrganizations <= 0) {
+          return `❌ Organization limit reached. Maximum: ${quotas.limits?.maxOwnedOrganizations}`;
+        }
+
+        const org = await client.createOrganization({
+          name: args.name,
+          description: args.description,
+        });
+
+        return [
+          `✅ Organization created successfully!`,
+          '',
+          `**#${org.id}**: ${org.name}`,
+          `**Type**: ${org.type || 'user'}`,
+          args.description ? `**Description**: ${args.description}` : null,
+        ].filter(Boolean).join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createOrganizationUpdateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Update organization details (owner only)',
+    args: {
+      organizationId: tool.schema.number()
+        .describe('Organization ID to update'),
+      name: tool.schema.string()
+        .optional()
+        .describe('New name'),
+      description: tool.schema.string()
+        .optional()
+        .describe('New description'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const org = await client.updateOrganization(args.organizationId, {
+          name: args.name,
+          description: args.description,
+        });
+
+        return `✅ Organization #${org.id} updated successfully!`;
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createOrganizationDeleteTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Delete organization permanently (owner only, irreversible)',
+    args: {
+      organizationId: tool.schema.number()
+        .describe('Organization ID to delete'),
+      confirm: tool.schema.boolean()
+        .default(false)
+        .describe('Type true to confirm deletion'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      if (!args.confirm) {
+        return [
+          '⚠️ **Warning**: This action is permanent and irreversible!',
+          '',
+          'All organization data will be deleted:',
+          '- All sprints and stories',
+          '- All members will be removed',
+          '- All files and settings',
+          '',
+          'Use `--confirm true` to proceed with deletion.',
+        ].join('\n');
+      }
+
+      try {
+        await client.deleteOrganization(args.organizationId);
+
+        return `✅ Organization #${args.organizationId} deleted successfully. This action cannot be undone.`;
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}

package/plugins/tools/schedule-tools.ts

@@ -0,0 +1,173 @@
+import { tool } from '@opencode-ai/plugin';
+import { ForLoopAPIClient } from '../capabilities/api-client';
+import { validateToken } from '../capabilities/auth';
+import { resolveSprintId } from '../capabilities/context-resolver';
+
+export function createScheduleTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Schedule a meeting with attendees (uses specialized schedule story type)',
+    args: {
+      sprintId: tool.schema.number()
+        .optional()
+        .describe('Sprint ID (auto-detected from branch or env if not provided)'),
+      title: tool.schema.string()
+        .describe('Meeting title'),
+      description: tool.schema.string()
+        .optional()
+        .describe('Meeting description or agenda'),
+      startAt: tool.schema.string()
+        .describe('Meeting start time (ISO format: YYYY-MM-DDTHH:MM:SSZ)'),
+      endAt: tool.schema.string()
+        .describe('Meeting end time (ISO format: YYYY-MM-DDTHH:MM:SSZ)'),
+      timezone: tool.schema.string()
+        .optional()
+        .default('UTC')
+        .describe('Timezone (e.g., "America/Los_Angeles")'),
+      videoUrl: tool.schema.string()
+        .optional()
+        .describe('Video meeting URL (Zoom, Google Meet, etc.)'),
+      location: tool.schema.string()
+        .optional()
+        .describe('Physical meeting location'),
+    },
+    async execute(args, context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        // Resolve sprint ID
+        const resolution = await resolveSprintId(args.sprintId, context.directory);
+        if (!resolution.sprintId) {
+          return [
+            '❌ No sprint ID provided.',
+            '',
+            'Please specify a sprint ID using one of these methods:',
+            '  1. Pass --sprintId flag',
+            '  2. Set FORLOOP_SPRINT_ID environment variable',
+            '  3. Use a git branch named sprint-XXX',
+          ].join('\n');
+        }
+
+        // Build schedule metadata
+        const scheduleMetadata = {
+          title: args.title,
+          description: args.description,
+          startAt: args.startAt,
+          endAt: args.endAt,
+          timezone: args.timezone,
+          videoUrl: args.videoUrl,
+          location: args.location,
+        };
+
+        // Create schedule story
+        const story = await client.createStory({
+          title: args.title,
+          description: args.description,
+          sprintId: resolution.sprintId,
+          type: 'schedule',
+          metadata: JSON.stringify(scheduleMetadata),
+          status: 'todo',
+        });
+
+        const formatDateTime = (isoString: string) => {
+          try {
+            const date = new Date(isoString);
+            return date.toLocaleString('en-US', {
+              weekday: 'short',
+              year: 'numeric',
+              month: 'short',
+              day: 'numeric',
+              hour: 'numeric',
+              minute: '2-digit',
+              timeZoneName: 'short',
+            });
+          } catch {
+            return isoString;
+          }
+        };
+
+        const lines: string[] = [
+          `✅ Meeting scheduled successfully!`,
+          '',
+          `**#${story.id}**: ${story.title}`,
+          `**Sprint**: #${resolution.sprintId}`,
+          `**When**: ${formatDateTime(args.startAt)} - ${formatDateTime(args.endAt)}`,
+        ];
+        if (args.videoUrl) lines.push(`**Video**: ${args.videoUrl}`);
+        if (args.location) lines.push(`**Location**: ${args.location}`);
+
+        return lines.join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createScheduleUpdateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Update an existing schedule/meeting',
+    args: {
+      storyId: tool.schema.number()
+        .describe('Schedule story ID to update'),
+      title: tool.schema.string()
+        .optional()
+        .describe('New title'),
+      description: tool.schema.string()
+        .optional()
+        .describe('New description'),
+      startAt: tool.schema.string()
+        .optional()
+        .describe('New start time'),
+      endAt: tool.schema.string()
+        .optional()
+        .describe('New end time'),
+      videoUrl: tool.schema.string()
+        .optional()
+        .describe('New video URL'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        // Get current story to merge metadata
+        const story = await client.getStory(args.storyId);
+        
+        if (story.type !== 'schedule') {
+          return `❌ Story #${args.storyId} is not a schedule meeting. Type: ${story.type}`;
+        }
+
+        // Parse existing metadata
+        const existingMetadata = story.metadata ? JSON.parse(story.metadata) : {};
+        
+        // Update with new values
+        const updatedMetadata = {
+          ...existingMetadata,
+          title: args.title !== undefined ? args.title : existingMetadata.title,
+          description: args.description !== undefined ? args.description : existingMetadata.description,
+          startAt: args.startAt !== undefined ? args.startAt : existingMetadata.startAt,
+          endAt: args.endAt !== undefined ? args.endAt : existingMetadata.endAt,
+          videoUrl: args.videoUrl !== undefined ? args.videoUrl : existingMetadata.videoUrl,
+        };
+
+        // Update story
+        await client.updateStory(args.storyId, {
+          title: args.title,
+          description: args.description,
+          metadata: updatedMetadata,
+        });
+
+        return `✅ Schedule #${args.storyId} updated successfully!`;
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}

package/plugins/tools/sprint-tools.ts

@@ -0,0 +1,287 @@
+import { tool } from '@opencode-ai/plugin';
+import { ForLoopAPIClient } from '../capabilities/api-client';
+import { resolveSprintId } from '../capabilities/context-resolver';
+import { validateToken } from '../capabilities/auth';
+import { getToken } from '../capabilities/token-storage';
+
+export function createSprintGetTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Get sprint details including stories, files, and AI agents',
+    args: {
+      sprintId: tool.schema.number()
+        .optional()
+        .describe('Sprint ID (defaults to FORLOOP_SPRINT_ID env or current branch)'),
+      includeStories: tool.schema.boolean()
+        .default(true)
+        .describe('Include stories in response'),
+      includeFiles: tool.schema.boolean()
+        .default(true)
+        .describe('Include files in response'),
+    },
+    async execute(args, context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      const resolution = await resolveSprintId(args.sprintId, context.directory);
+      
+      if (!resolution.sprintId) {
+        return [
+          '❌ No sprint ID provided.',
+          '',
+          'Please specify a sprint ID using one of these methods:',
+          '  1. Pass --sprintId flag',
+          '  2. Set FORLOOP_SPRINT_ID environment variable',
+          '  3. Use a git branch named sprint-XXX (e.g., sprint-123)',
+        ].join('\n');
+      }
+
+      try {
+        const sprint = await client.getSprint(resolution.sprintId, {
+          includeStories: args.includeStories,
+          includeFiles: args.includeFiles,
+        });
+
+        const lines = [
+          `📋 Sprint #${sprint.id}: ${sprint.title}`,
+          '',
+          `**Status**: ${sprint.status}`,
+          `**Period**: ${formatDate(sprint.startDate)} - ${formatDate(sprint.endDate)}`,
+          `**Stories**: ${sprint.stories?.length || 0}`,
+          '',
+        ];
+
+        if (sprint.summary) {
+          lines.push(`**Summary**: ${sprint.summary}`);
+          lines.push('');
+        }
+
+        if (sprint.stories?.length) {
+          lines.push('**Stories**:', '');
+          for (const story of sprint.stories) {
+            const icon = getStoryStatusIcon(story.status);
+            lines.push(`- ${icon} #${story.id} ${story.title} (${story.status})`);
+          }
+        }
+
+        return lines.join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createSprintListTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'List all accessible sprints',
+    args: {
+      organizationId: tool.schema.number()
+        .optional()
+        .describe('Filter by organization ID'),
+      includeSystemOrg: tool.schema.boolean()
+        .default(true)
+        .describe('Include sprints from system organization'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      const params: Record<string, string> = {};
+      if (args.organizationId) params.organizationId = String(args.organizationId);
+      
+      try {
+        const sprints = await client.listSprints(params);
+
+        if (!sprints.length) {
+          return 'No sprints found.';
+        }
+
+        const lines = ['📋 Sprints:', ''];
+        for (const sprint of sprints) {
+          const statusIcon = getStatusIcon(sprint.status);
+          const orgInfo = sprint.organizationName ? ` (${sprint.organizationName})` : '';
+          lines.push(
+            `- ${statusIcon} #${sprint.id} ${sprint.title}${orgInfo} - ${sprint.status}`
+          );
+        }
+
+        return lines.join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+function formatDate(dateString: string): string {
+  return new Date(dateString).toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  });
+}
+
+function getStoryStatusIcon(status: string): string {
+  const icons: Record<string, string> = {
+    todo: '📝',
+    in_progress: '🚧',
+    done: '✅',
+    blocked: '🚫',
+  };
+  return icons[status] || '📌';
+}
+
+function getStatusIcon(status: string): string {
+  const icons: Record<string, string> = {
+    planned: '📅',
+    'in-progress': '🚧',
+    completed: '✅',
+  };
+  return icons[status] || '📌';
+}
+
+export function createSprintCreateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Create a new sprint with specified dates and settings',
+    args: {
+      title: tool.schema.string()
+        .describe('Sprint title'),
+      description: tool.schema.string()
+        .optional()
+        .describe('Sprint description'),
+      startDate: tool.schema.string()
+        .describe('Sprint start date (ISO format: YYYY-MM-DD)'),
+      endDate: tool.schema.string()
+        .describe('Sprint end date (ISO format: YYYY-MM-DD)'),
+      isPrivate: tool.schema.boolean()
+        .default(false)
+        .describe('Whether sprint is private'),
+      organizationId: tool.schema.number()
+        .optional()
+        .describe('Organization ID (defaults to user default)'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const sprint = await client.createSprint({
+          title: args.title,
+          description: args.description,
+          startDate: args.startDate,
+          endDate: args.endDate,
+          isPrivate: args.isPrivate,
+          organizationId: args.organizationId,
+        });
+
+        const lines = [
+          '✅ Sprint created successfully!',
+          '',
+          `**#${sprint.id}**: ${sprint.title}`,
+          `**Period**: ${formatDate(sprint.startDate)} - ${formatDate(sprint.endDate)}`,
+          `**Status**: ${sprint.status}`,
+        ];
+
+        if (sprint.isPrivate) {
+          lines.push('**Visibility**: Private');
+        }
+
+        return lines.join('\n');
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createSprintUpdateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Update sprint details',
+    args: {
+      sprintId: tool.schema.number()
+        .describe('Sprint ID to update'),
+      title: tool.schema.string()
+        .optional()
+        .describe('New title'),
+      description: tool.schema.string()
+        .optional()
+        .describe('New description'),
+      startDate: tool.schema.string()
+        .optional()
+        .describe('New start date (ISO format)'),
+      endDate: tool.schema.string()
+        .optional()
+        .describe('New end date (ISO format)'),
+      isPrivate: tool.schema.boolean()
+        .optional()
+        .describe('Update visibility setting'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const updateData: any = {};
+        if (args.title !== undefined) updateData.title = args.title;
+        if (args.description !== undefined) updateData.description = args.description;
+        if (args.startDate !== undefined) updateData.startDate = args.startDate;
+        if (args.endDate !== undefined) updateData.endDate = args.endDate;
+        if (args.isPrivate !== undefined) updateData.isPrivate = args.isPrivate;
+
+        const sprint = await client.updateSprint(args.sprintId, updateData);
+
+        return `✅ Sprint #${sprint.id} updated successfully!`;
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}
+
+export function createSprintDeleteTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Delete a sprint (use with caution)',
+    args: {
+      sprintId: tool.schema.number()
+        .describe('Sprint ID to delete'),
+      confirm: tool.schema.boolean()
+        .default(false)
+        .describe('Confirm deletion'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error;
+      }
+      client.setToken?.(tokenResult.token);
+
+      if (!args.confirm) {
+        return [
+          '⚠️ Warning: This will permanently delete the sprint and all its stories.',
+          '',
+          'Use --confirm true to proceed.',
+        ].join('\n');
+      }
+
+      try {
+        await client.deleteSprint(args.sprintId);
+
+        return `✅ Sprint #${args.sprintId} deleted successfully!`;
+      } catch (error: any) {
+        return `❌ Error: ${error.message}`;
+      }
+    },
+  });
+}