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

package/plugins/capabilities/config.ts

@@ -0,0 +1,195 @@
+import fs from 'fs';
+import path from 'path';
+
+export const PROD_API_URL = 'https://api.forloop.cc';
+export const DEV_API_URL = 'https://api.dev.forloop.cc';
+
+export const PROD_TOKENS_URL = 'https://forloop.cc/profile?tab=api-tokens';
+export const DEV_TOKENS_URL = 'https://dev.forloop.cc/profile?tab=api-tokens';
+
+export type Environment = 'development' | 'production' | 'custom';
+
+export interface ForLoopConfig {
+  apiUrl: string;
+  environment: Environment;
+  tokenStorage: 'global' | 'project';
+  debug: boolean;
+  allowDev: boolean;
+}
+
+type JsonObject = Record<string, unknown>;
+
+const readJsonFileIfExists = (filePath: string): JsonObject | null => {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw) as JsonObject;
+  } catch {
+    return null;
+  }
+};
+
+const getHomeDir = (): string => {
+  return process.env.HOME || process.env.USERPROFILE || '';
+};
+
+const getProjectConfig = (): JsonObject | null => {
+  return readJsonFileIfExists(path.join(process.cwd(), 'opencode.json'));
+};
+
+const getGlobalConfig = (): JsonObject | null => {
+  const home = getHomeDir();
+  if (!home) return null;
+  return readJsonFileIfExists(path.join(home, '.config', 'opencode', 'config.json'));
+};
+
+const getNested = (obj: JsonObject | null, keys: string[]): unknown => {
+  let cur: unknown = obj;
+  for (const key of keys) {
+    if (!cur || typeof cur !== 'object') return undefined;
+    cur = (cur as JsonObject)[key];
+  }
+  return cur;
+};
+
+const isTruthy = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value.toLowerCase() === 'true' || value === '1';
+  return false;
+};
+
+const normalizeUrl = (value: unknown): string | null => {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed;
+};
+
+const isDevUrl = (apiUrl: string): boolean => {
+  return apiUrl.includes('api.dev.forloop.cc') || apiUrl.includes('dev.forloop.cc');
+};
+
+const resolveAllowDev = (projectConfig: JsonObject | null, globalConfig: JsonObject | null): boolean => {
+  return (
+    isTruthy(process.env.FORLOOP_ALLOW_DEV) ||
+    isTruthy(getNested(projectConfig, ['forloop', 'allowDev'])) ||
+    isTruthy(getNested(globalConfig, ['forloop', 'allowDev']))
+  );
+};
+
+const resolveApiUrl = (projectConfig: JsonObject | null, globalConfig: JsonObject | null, allowDev: boolean): string => {
+  const envApiUrl = normalizeUrl(process.env.FORLOOP_API_URL || process.env.FORLOOP_API_BASE);
+  if (envApiUrl) {
+    if (isDevUrl(envApiUrl) && !allowDev) {
+      console.warn('[ForLoop Config] Dev API URL ignored (set FORLOOP_ALLOW_DEV=true to enable)');
+      return PROD_API_URL;
+    }
+    return envApiUrl;
+  }
+
+  const envName = normalizeUrl(process.env.FORLOOP_ENV);
+  if (envName) {
+    if (envName === 'production') return PROD_API_URL;
+    if (envName === 'development') {
+      if (!allowDev) {
+        console.warn('[ForLoop Config] FORLOOP_ENV=development ignored (set FORLOOP_ALLOW_DEV=true to enable)');
+        return PROD_API_URL;
+      }
+      return DEV_API_URL;
+    }
+  }
+
+  const projectApiUrl = normalizeUrl(getNested(projectConfig, ['forloop', 'apiUrl']));
+  if (projectApiUrl) {
+    if (isDevUrl(projectApiUrl) && !allowDev) {
+      console.warn('[ForLoop Config] Project dev API URL ignored (set forloop.allowDev=true or FORLOOP_ALLOW_DEV=true)');
+      return PROD_API_URL;
+    }
+    return projectApiUrl;
+  }
+
+  const globalApiUrl = normalizeUrl(getNested(globalConfig, ['forloop', 'apiUrl']));
+  if (globalApiUrl) {
+    if (isDevUrl(globalApiUrl) && !allowDev) {
+      console.warn('[ForLoop Config] Global dev API URL ignored (set forloop.allowDev=true or FORLOOP_ALLOW_DEV=true)');
+      return PROD_API_URL;
+    }
+    return globalApiUrl;
+  }
+
+  return PROD_API_URL;
+};
+
+const detectEnvironment = (apiUrl: string): Environment => {
+  if (apiUrl.includes('dev.forloop.cc')) {
+    return 'development';
+  }
+  if (apiUrl.includes('api.forloop.cc')) {
+    return 'production';
+  }
+  return 'custom';
+};
+
+export const getConfig = (): ForLoopConfig => {
+  const projectConfig = getProjectConfig();
+  const globalConfig = getGlobalConfig();
+  const allowDev = resolveAllowDev(projectConfig, globalConfig);
+  const apiUrl = resolveApiUrl(projectConfig, globalConfig, allowDev);
+  
+  return {
+    apiUrl,
+    environment: detectEnvironment(apiUrl),
+    tokenStorage: 'global',
+    debug: process.env.FORLOOP_DEBUG === 'true',
+    allowDev,
+  };
+};
+
+export const isDevelopment = (): boolean => {
+  const config = getConfig();
+  return config.environment === 'development' || process.env.NODE_ENV === 'development';
+};
+
+export const isProduction = (): boolean => {
+  const config = getConfig();
+  return config.environment === 'production';
+};
+
+export const printConfig = (): void => {
+  const config = getConfig();
+  console.log('[ForLoop Config]', {
+    apiUrl: config.apiUrl,
+    environment: config.environment,
+    debug: config.debug,
+    allowDev: config.allowDev,
+  });
+};
+
+export const getTokensUrl = (): string => {
+  const config = getConfig();
+  if (config.environment === 'development') return DEV_TOKENS_URL;
+  return PROD_TOKENS_URL;
+};
+
+/**
+ * Detect if running in AWS Lambda environment
+ * Uses standard Lambda environment variables
+ */
+export const isLambdaExecution = (): boolean => {
+  const forced = (process.env.FORLOOP_EXECUTION_CONTEXT || '').toLowerCase();
+  if (forced === 'lambda' || forced === 'aws_lambda' || forced === 'aws-lambda') return true;
+  return !!(
+    process.env.AWS_LAMBDA_FUNCTION_NAME ||
+    process.env.AWS_EXECUTION_ENV ||
+    process.env.LAMBDA_TASK_ROOT
+  );
+};
+
+/**
+ * Get the execution context (local or lambda)
+ */
+export type ExecutionContext = 'local' | 'lambda';
+
+export const getExecutionContext = (): ExecutionContext => {
+  return isLambdaExecution() ? 'lambda' : 'local';
+};

package/plugins/capabilities/context-resolver.ts

@@ -0,0 +1,106 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const execAsync = promisify(exec);
+
+export interface ContextResolution {
+  sprintId?: number;
+  branch?: string;
+  source: 'provided' | 'env' | 'branch' | 'manifest' | 'config';
+}
+
+export async function getCurrentBranch(directory?: string): Promise<string> {
+  try {
+    const result = await execAsync('git rev-parse --abbrev-ref HEAD', {
+      cwd: directory,
+    });
+    return result.stdout.trim();
+  } catch (error) {
+    throw new Error('Git not available or not in a repository');
+  }
+}
+
+export async function resolveSprintFromBranch(branch: string): Promise<number | null> {
+  const match = branch.match(/sprint-(\d+)/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+
+export async function resolveSprintId(
+  providedId?: number,
+  directory?: string
+): Promise<ContextResolution> {
+  if (providedId) {
+    return { sprintId: providedId, source: 'provided' };
+  }
+
+  const envSprintId = process.env.FORLOOP_SPRINT_ID;
+  if (envSprintId) {
+    return { sprintId: parseInt(envSprintId, 10), source: 'env' };
+  }
+
+  const manifestSprintId = getActiveSprintIdFromManifest(directory);
+  if (manifestSprintId) {
+    return { sprintId: manifestSprintId, source: 'manifest' };
+  }
+
+  try {
+    const branch = await getCurrentBranch(directory);
+    const sprintId = await resolveSprintFromBranch(branch);
+    if (sprintId) {
+      return { sprintId, branch, source: 'branch' };
+    }
+  } catch (error) {
+  }
+
+  return { source: 'config' };
+}
+
+function getActiveSprintIdFromManifest(directory?: string): number | null {
+  const candidates: string[] = [];
+  if (directory) {
+    candidates.push(path.join(directory, '.forloop', 'manifest.json'));
+  }
+
+  const home = process.env.HOME;
+  if (home) {
+    candidates.push(path.join(home, '.forloop', 'manifest.json'));
+  }
+
+  for (const filePath of candidates) {
+    try {
+      if (!fs.existsSync(filePath)) continue;
+      const raw = fs.readFileSync(filePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      const id = parsed?.activeSprintId;
+      if (Number.isFinite(id)) return Number(id);
+    } catch {
+    }
+  }
+
+  return null;
+}
+
+export const DEFAULT_HOME = '/tmp/home';
+
+export function getSprintDir(sprintId: number): string {
+  return `sprint-${sprintId}`;
+}
+
+export function getForloopRoot(sprintId?: number): string {
+  const home = process.env.HOME || DEFAULT_HOME;
+  const root = path.join(home, '.forloop');
+  if (sprintId !== undefined) {
+    return path.join(root, getSprintDir(sprintId));
+  }
+  return root;
+}
+
+export function getManifestPath(): string {
+  const home = process.env.HOME || DEFAULT_HOME;
+  return path.join(home, '.forloop', 'manifest.json');
+}

package/plugins/capabilities/token-storage.ts

@@ -0,0 +1,98 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export interface TokenProfile {
+  version: string;  // Schema version for future migrations
+  default?: string;
+  profiles?: Record<string, string>;
+  lastUpdated: string;
+  note: string;  // Clear indication this is ForLoop-specific
+}
+
+const getTokenPath = (): string => {
+  return path.join(
+    process.env.HOME || process.env.USERPROFILE || '.',
+    '.config',
+    'forloop',
+    'tokens.json'
+  );
+};
+
+export async function loadTokens(): Promise<TokenProfile> {
+  const tokenPath = getTokenPath();
+  
+  try {
+    const content = await fs.readFile(tokenPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      return { 
+        version: '1.0',
+        note: 'ForLoop API tokens - do not share',
+        lastUpdated: new Date().toISOString() 
+      };
+    }
+    throw error;
+  }
+}
+
+export async function saveTokens(tokens: TokenProfile): Promise<void> {
+  const tokenPath = getTokenPath();
+  const configDir = path.dirname(tokenPath);
+  
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(
+    tokenPath,
+    JSON.stringify(tokens, null, 2),
+    { mode: 0o600 }
+  );
+}
+
+export async function getToken(profile?: string): Promise<string | null> {
+  const tokens = await loadTokens();
+  
+  if (profile && tokens.profiles?.[profile]) {
+    return tokens.profiles[profile];
+  }
+  
+  // Check top-level default first, then fall back to profiles["default"]
+  if (tokens.default) return tokens.default;
+  if (tokens.profiles?.['default']) return tokens.profiles['default'];
+  
+  return null;
+}
+
+export async function setToken(token: string, profile?: string): Promise<void> {
+  const tokens = await loadTokens();
+  
+  // Ensure version and note are set
+  tokens.version = '1.0';
+  tokens.note = 'ForLoop API tokens - do not share';
+  
+  if (profile) {
+    if (!tokens.profiles) {
+      tokens.profiles = {};
+    }
+    tokens.profiles[profile] = token;
+  } else {
+    tokens.default = token;
+  }
+  
+  tokens.lastUpdated = new Date().toISOString();
+  await saveTokens(tokens);
+}
+
+export async function clearToken(profile?: string): Promise<void> {
+  const tokens = await loadTokens();
+
+  if (profile) {
+    if (tokens.profiles) {
+      delete tokens.profiles[profile];
+    }
+  } else {
+    delete tokens.default;
+  }
+
+  tokens.lastUpdated = new Date().toISOString();
+  await saveTokens(tokens);
+}

package/plugins/forloop-plugin.ts

@@ -0,0 +1,186 @@
+import { getToken } from './capabilities/token-storage';
+import { ForLoopAPIClient } from './capabilities/api-client';
+import { getConfig, isLambdaExecution } from './capabilities/config';
+import { 
+  createSprintGetTool, 
+  createSprintListTool,
+  createSprintCreateTool,
+  createSprintUpdateTool,
+  createSprintDeleteTool,
+} from './tools/sprint-tools';
+import { 
+  createStoryCreateTool, 
+  createStoryUpdateTool, 
+  createStoryDeleteTool,
+  createStoryGetTool,
+} from './tools/story-tools';
+import { 
+  createTemplateListTool,
+  createStoryFromTemplateTool,
+} from './tools/template-tools';
+import { 
+  createUserProfileTool,
+  createUserQuotasTool,
+  createOrganizationQuotasTool,
+} from './tools/user-tools';
+import {
+  createOrganizationListTool,
+  createOrganizationGetTool,
+  createOrganizationCreateTool,
+  createOrganizationUpdateTool,
+  createOrganizationDeleteTool,
+} from './tools/organization-tools';
+import {
+  createFileUploadTool,
+  createFileListTool,
+  createFileDeleteTool,
+  createFileDownloadUrlTool,
+} from './tools/file-tools';
+import {
+  createScheduleTool,
+  createScheduleUpdateTool,
+} from './tools/schedule-tools';
+import {
+  createDocFolderTool,
+} from './tools/folder-tools';
+import {
+  createAivyDocFolderEnsureTool,
+  createAivyDocFolderGetTool,
+  createS3ToLocalSyncTool,
+  createLocalToS3SyncTool,
+} from './tools/sync-tools';
+import { createAgentQueryTool, createTokenSetTool, createTokenGetTool } from './tools/agent-tools';
+import { 
+  createAgentSuggestTool,
+  createStoryBreakdownTool,
+  createStoryEstimateTool,
+  createConversationHistoryTool,
+  createClearHistoryTool
+} from './tools/agent-suggestion-tools';
+import {
+  createAgentListTool,
+  createSprintAiAgentsUpdateTool,
+} from './tools/agent-sprint-tools';
+import { createAITriggerTools } from './tools/ai-trigger-tools';
+import { createDeveloperStatusTool } from './tools/developer-status-tool';
+import { injectEnvironment } from './hooks/shell-env';
+import { createChatMessageHook, createEventHook } from './hooks/message-recorder';
+
+export default async (ctx: any) => {
+  const config = getConfig();
+  const token = (await getToken()) || '';
+
+  console.log(
+    `[ForLoop] Plugin initialized - ${config.environment} (${config.apiUrl}) execution=${isLambdaExecution() ? 'lambda' : 'local'} forced=${process.env.FORLOOP_EXECUTION_CONTEXT || 'not set'}`
+  );
+  if (!token) {
+    console.log('[ForLoop] No token configured - tools will ask you to set one');
+  }
+
+  const client = new ForLoopAPIClient({
+    token,
+    baseUrl: config.apiUrl,
+  });
+
+  const aiTriggerTools = createAITriggerTools(client);
+
+  return {
+    tool: {
+      // Token Management
+      'forloopTokenSet': createTokenSetTool(client),
+      'forloopTokenGet': createTokenGetTool(),
+      
+      // Sprint Operations
+      'forloopSprintList': createSprintListTool(client),
+      'forloopSprintGet': createSprintGetTool(client),
+      'forloopSprintCreate': createSprintCreateTool(client),
+      'forloopSprintUpdate': createSprintUpdateTool(client),
+      'forloopSprintDelete': createSprintDeleteTool(client),
+      
+      // Story Operations
+      'forloopStoryCreate': createStoryCreateTool(client),
+      'forloopStoryGet': createStoryGetTool(client),
+      'forloopStoryUpdate': createStoryUpdateTool(client),
+      'forloopStoryDelete': createStoryDeleteTool(client),
+      
+      // Template Operations
+      'forloopTemplateList': createTemplateListTool(client),
+      'forloopStoryTemplate': createStoryFromTemplateTool(client),
+      
+      // User & Quota Operations
+      'forloopUserProfile': createUserProfileTool(client),
+      'forloopUserQuotas': createUserQuotasTool(client),
+      'forloopOrganizationQuotas': createOrganizationQuotasTool(client),
+      
+      // Organization Management
+      'forloopOrganizationList': createOrganizationListTool(client),
+      'forloopOrganizationGet': createOrganizationGetTool(client),
+      'forloopOrganizationCreate': createOrganizationCreateTool(client),
+      'forloopOrganizationUpdate': createOrganizationUpdateTool(client),
+      'forloopOrganizationDelete': createOrganizationDeleteTool(client),
+      
+      // File Upload & Management
+      'forloopFileUpload': createFileUploadTool(client),
+      'forloopFileList': createFileListTool(client),
+      'forloopFileDelete': createFileDeleteTool(client),
+      'forloopFileDownload': createFileDownloadUrlTool(client),
+      
+      // Schedule Meetings
+      'forloopScheduleCreate': createScheduleTool(client),
+      'forloopScheduleUpdate': createScheduleUpdateTool(client),
+      
+      // Document Folders
+      'forloopDocFolder': createDocFolderTool(client),
+
+      // Aivy Doc Sync
+      'forloopSyncAivyFolder': createAivyDocFolderEnsureTool(client),
+      'forloopAivyDocGet': createAivyDocFolderGetTool(client),
+      'forloopSyncS3ToLocal': createS3ToLocalSyncTool(client),
+      'forloopSyncLocalToS3': createLocalToS3SyncTool(client),
+      
+      // AI Agent Tools
+      'forloopAgentQuery': createAgentQueryTool(client),
+      'forloopAgentSuggest': createAgentSuggestTool(client),
+      'forloopAgentBreakdown': createStoryBreakdownTool(client),
+      'forloopAgentEstimate': createStoryEstimateTool(client),
+      'forloopAgentHistory': createConversationHistoryTool(client),
+      'forloopAgentClear': createClearHistoryTool(client),
+      'forloopAiAgentList': createAgentListTool(client),
+      'forloopSprintAiAgentsUpdate': createSprintAiAgentsUpdateTool(client),
+      
+      // AI Execution Tools
+      ...aiTriggerTools,
+      'forloopDeveloperStatus': createDeveloperStatusTool(client),
+    },
+    event: createEventHook(client),
+    'chat.message': createChatMessageHook(client),
+    'shell.env': injectEnvironment,
+    'tool.execute.before': (input: any, output: any) => {
+      if (!(globalThis as any).__toolHookKeysLogged) {
+        (globalThis as any).__toolHookKeysLogged = 1;
+        console.log('[ForLoop] tool.execute.before input keys:', Object.keys(input || {}).join(', '));
+      }
+      const agent = input.agent || input.agentName || input.sourceAgent || input.agentId || '';
+      const args = typeof output?.args === 'object' ? JSON.stringify(output.args) : String(output?.args || '');
+      console.log(`[forloop][${agent}] ▶ ${input.tool}`, args.substring(0, 400));
+    },
+    'tool.execute.after': (input: any, output: any) => {
+      const agent = input.agent || input.agentName || input.sourceAgent || input.agentId || '';
+      const summary = typeof output === 'string'
+        ? output.substring(0, 200)
+        : (output?.text || output?.message || JSON.stringify(output).substring(0, 200));
+      console.log(`[forloop][${agent}] ✓ ${input.tool} completed:`, summary);
+    },
+  };
+};
+
+export { ForLoopAPIClient } from './capabilities/api-client';
+export type { APIError, CreateStoryRequest, CreateSprintRequest, ListSprintsParams, SprintOptions } from './capabilities/api-client';
+export { getConfig, isLambdaExecution, PROD_API_URL, DEV_API_URL } from './capabilities/config';
+export type { ForLoopConfig } from './capabilities/config';
+export { getToken, setToken, clearToken } from './capabilities/token-storage';
+export type { TokenProfile } from './capabilities/token-storage';
+export { validateToken, detectTokenType } from './capabilities/auth';
+export type { TokenValidationResult } from './capabilities/auth';
+export { resolveSprintId, getCurrentBranch, resolveSprintFromBranch, getForloopRoot, getManifestPath } from './capabilities/context-resolver';
+export type { ContextResolution } from './capabilities/context-resolver';