@forloop-cc/forloop-opencode-plugin-planner 2.2.12 → 2.2.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@forloop-cc/forloop-opencode-plugin-planner",
-  "version": "2.2.12",
+  "version": "2.2.13",
   "description": "ForLoop integration plugin for opencode — Sprint, story, and agent tools for the ForLoop platform",
   "type": "module",
   "license": "MIT",

package/plugins/capabilities/api-client.ts

@@ -23,6 +23,9 @@ interface ClientConfig {
 export interface SprintOptions {
   includeStories?: boolean;
   includeFiles?: boolean;
+  allStories?: boolean;
+  subSprintId?: number;
+  includeSubSprints?: boolean;
 }
 
 export interface ListSprintsParams {
@@ -259,6 +262,9 @@ export class ForLoopAPIClient {
       includeStories: options?.includeStories !== false ? 'true' : 'false',
       includeFiles: options?.includeFiles !== false ? 'true' : 'false',
     });
+    if (options?.allStories) query.set('allStories', 'true');
+    if (options?.subSprintId) query.set('subSprintId', String(options.subSprintId));
+    if (options?.includeSubSprints) query.set('includeSubSprints', 'true');
     return this.request(`/api/opencode/sprints/${id}?${query}`);
   }
 
@@ -309,6 +315,39 @@ export class ForLoopAPIClient {
     });
   }
 
+  async getSubSprints(sprintId: number): Promise<any[]> {
+    return this.request(`/api/opencode/sprints/${sprintId}/sub-sprints`);
+  }
+
+  async createSubSprint(sprintId: number, data: {
+    title?: string;
+    startDate: string;
+    endDate: string;
+  }): Promise<any> {
+    return this.request(`/api/opencode/sprints/${sprintId}/sub-sprints`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async updateSubSprint(subSprintId: number, data: Partial<{
+    title: string;
+    startDate: string;
+    endDate: string;
+    status: 'planned' | 'in_progress' | 'completed';
+  }>): Promise<any> {
+    return this.request(`/api/opencode/sub-sprints/${subSprintId}`, {
+      method: 'PUT',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteSubSprint(subSprintId: number): Promise<void> {
+    await this.request(`/api/opencode/sub-sprints/${subSprintId}`, {
+      method: 'DELETE',
+    });
+  }
+
   async addStoryComment(storyId: number, body: string, authorAgentKey?: string): Promise<any> {
     const payload: Record<string, unknown> = { body };
     if (authorAgentKey) payload.authorAgentKey = authorAgentKey;

package/plugins/forloop-plugin.ts

@@ -7,6 +7,10 @@ import {
   createSprintCreateTool,
   createSprintUpdateTool,
   createSprintDeleteTool,
+  createSubSprintListTool,
+  createSubSprintCreateTool,
+  createSubSprintUpdateTool,
+  createSubSprintDeleteTool,
 } from './tools/sprint-tools';
 import { 
   createStoryCreateTool, 
@@ -102,6 +106,12 @@ export default async (ctx: any) => {
       'forloopSprintUpdate': createSprintUpdateTool(client),
       'forloopSprintDelete': createSprintDeleteTool(client),
       
+      // Sub-Sprint (Iteration) Operations
+      'forloopSubSprintList'  : createSubSprintListTool(client),
+      'forloopSubSprintCreate' : createSubSprintCreateTool(client),
+      'forloopSubSprintUpdate' : createSubSprintUpdateTool(client),
+      'forloopSubSprintDelete' : createSubSprintDeleteTool(client),
+      
       // Story Operations
       'forloopStoryCreate': createStoryCreateTool(client),
       'forloopStoryGet': createStoryGetTool(client),

package/plugins/tools/sprint-tools.ts

@@ -17,6 +17,9 @@ export function createSprintGetTool(client: ForLoopAPIClient) {
       includeFiles: tool.schema.boolean()
         .default(true)
         .describe('Include files in response'),
+      includeSubSprints: tool.schema.boolean()
+        .default(true)
+        .describe('Include sub-sprints array in response'),
     },
     async execute(args, context) {
       const tokenResult = await validateToken();
@@ -42,6 +45,7 @@ export function createSprintGetTool(client: ForLoopAPIClient) {
         const sprint = await client.getSprint(resolution.sprintId, {
           includeStories: args.includeStories,
           includeFiles: args.includeFiles,
+          includeSubSprints: args.includeSubSprints,
         });
 
         const lines = [
@@ -288,3 +292,145 @@ export function createSprintDeleteTool(client: ForLoopAPIClient) {
     },
   });
 }
+
+export function createSubSprintListTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'List all iterations (sub-sprints) within a sprint',
+    args: {
+      sprintId: tool.schema.number()
+        .optional()
+        .describe('Sprint ID (defaults to FORLOOP_SPRINT_ID env or current branch)'),
+    },
+    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 resolved. Use --sprintId, set FORLOOP_SPRINT_ID, or use a sprint-XXX branch.'
+      }
+      try {
+        const subSprints = await client.getSubSprints(resolution.sprintId)
+        if (subSprints.length === 0) {
+          return `Sprint #${resolution.sprintId} has no iterations yet.`
+        }
+        const lines = [`Iterations for sprint #${resolution.sprintId}:`, '']
+        for (const s of subSprints) {
+          const active = s.status === 'in_progress' ? ' ▶ ACTIVE' : ''
+          lines.push(
+            `  #${s.id}: ${s.title} | ${formatDate(s.startDate)} – ${formatDate(s.endDate)} | ${s.status}${active}`
+          )
+        }
+        return lines.join('\n')
+      } catch (error: any) {
+        return `Failed to list iterations: ${error.message}`
+      }
+    },
+  })
+}
+
+export function createSubSprintCreateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Create a new iteration (sub-sprint). The previously active iteration is auto-completed.',
+    args: {
+      sprintId: tool.schema.number()
+        .optional()
+        .describe('Sprint ID (defaults to FORLOOP_SPRINT_ID env or current branch)'),
+      title: tool.schema.string()
+        .optional()
+        .describe('Iteration title (auto-generates as "Sprint Title — Iteration N" if not provided)'),
+      startDate: tool.schema.string()
+        .describe('Start date (YYYY-MM-DD)'),
+      endDate: tool.schema.string()
+        .describe('End date (YYYY-MM-DD)'),
+    },
+    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 resolved. Use --sprintId, set FORLOOP_SPRINT_ID, or use a sprint-XXX branch.'
+      }
+      if (!args.startDate || !args.endDate) {
+        return 'startDate and endDate are required (YYYY-MM-DD format).'
+      }
+      try {
+        const subSprint = await client.createSubSprint(resolution.sprintId, {
+          title: args.title,
+          startDate: args.startDate,
+          endDate: args.endDate,
+        })
+        return `Iteration created: #${subSprint.id} "${subSprint.title}" (${formatDate(subSprint.startDate)} – ${formatDate(subSprint.endDate)}) status: ${subSprint.status}`
+      } catch (error: any) {
+        return `Failed to create iteration: ${error.message}`
+      }
+    },
+  })
+}
+
+export function createSubSprintUpdateTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Update an iteration (sub-sprint) title, dates, or status. Activating an iteration (status: in_progress) auto-completes the previous one.',
+    args: {
+      subSprintId: tool.schema.number()
+        .describe('Sub-sprint ID to update'),
+      title: tool.schema.string()
+        .optional()
+        .describe('New iteration title'),
+      startDate: tool.schema.string()
+        .optional()
+        .describe('New start date (YYYY-MM-DD)'),
+      endDate: tool.schema.string()
+        .optional()
+        .describe('New end date (YYYY-MM-DD)'),
+      status: tool.schema.string()
+        .optional()
+        .describe('New status: planned, in_progress, or completed'),
+    },
+    async execute(args, context) {
+      const tokenResult = await validateToken()
+      if (!tokenResult.valid) return tokenResult.error
+      client.setToken?.(tokenResult.token)
+
+      if (!args.subSprintId) return 'subSprintId is required.'
+      try {
+        const updateData: Record<string, unknown> = {}
+        if (args.title !== undefined) updateData.title = args.title
+        if (args.startDate !== undefined) updateData.startDate = args.startDate
+        if (args.endDate !== undefined) updateData.endDate = args.endDate
+        if (args.status !== undefined) updateData.status = args.status
+        if (Object.keys(updateData).length === 0) return 'No update fields provided.'
+        const updated = await client.updateSubSprint(args.subSprintId, updateData)
+        return `Iteration updated: #${updated.id} "${updated.title}" status: ${updated.status}`
+      } catch (error: any) {
+        return `Failed to update iteration: ${error.message}`
+      }
+    },
+  })
+}
+
+export function createSubSprintDeleteTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Soft-delete an iteration (sub-sprint). Linked stories retain their subSprintId and will not appear in default sprint views.',
+    args: {
+      subSprintId: tool.schema.number()
+        .describe('Sub-sprint ID to delete'),
+    },
+    async execute(args, context) {
+      const tokenResult = await validateToken()
+      if (!tokenResult.valid) return tokenResult.error
+      client.setToken?.(tokenResult.token)
+
+      if (!args.subSprintId) return 'subSprintId is required.'
+      try {
+        await client.deleteSubSprint(args.subSprintId)
+        return `Iteration #${args.subSprintId} deleted.`
+      } catch (error: any) {
+        return `Failed to delete iteration: ${error.message}`
+      }
+    },
+  })
+}