@vibescope/mcp-server 0.4.3 → 0.4.5

package/src/api-client/file-checkouts.ts

@@ -0,0 +1,115 @@
+/**
+ * File Checkouts API Methods
+ *
+ * Methods for multi-agent file coordination:
+ * - checkoutFile: Check out a file for editing
+ * - checkinFile: Check in a file after editing
+ * - getFileCheckouts: Get file checkouts for a project
+ * - abandonCheckout: Force-release a checkout
+ * - getFileCheckoutsStats: Get aggregate checkout statistics
+ * - isFileAvailable: Check if a file is available for checkout
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface FileCheckoutsMethods {
+	checkoutFile(projectId: string, filePath: string, reason?: string, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		checkout_id: string;
+		file_path: string;
+		already_checked_out?: boolean;
+		message: string;
+	}>>;
+
+	checkinFile(params: {
+		checkout_id?: string;
+		project_id?: string;
+		file_path?: string;
+		summary?: string;
+	}, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		checkout_id: string;
+		message: string;
+	}>>;
+
+	getFileCheckouts(projectId: string, options?: {
+		status?: string;
+		file_path?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		checkouts: Array<{
+			id: string;
+			file_path: string;
+			status: string;
+			checked_out_at: string;
+			checkout_reason?: string;
+			checked_in_at?: string;
+			checkin_summary?: string;
+			checked_out_by?: string;
+		}>;
+	}>>;
+
+	abandonCheckout(params: {
+		checkout_id?: string;
+		project_id?: string;
+		file_path?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		checkout_id: string;
+		message: string;
+	}>>;
+
+	getFileCheckoutsStats(projectId: string): Promise<ApiResponse<{
+		total: number;
+		by_status: Record<string, number>;
+	}>>;
+
+	isFileAvailable(projectId: string, filePath: string): Promise<ApiResponse<{
+		available: boolean;
+		checkout?: {
+			id: string;
+			checked_out_by?: string;
+			checked_out_at: string;
+			checkout_reason?: string;
+		};
+	}>>;
+}
+
+export function createFileCheckoutsMethods(proxy: ProxyFn): FileCheckoutsMethods {
+	return {
+		async checkoutFile(projectId, filePath, reason, sessionId) {
+			return proxy('checkout_file', {
+				project_id: projectId,
+				file_path: filePath,
+				reason
+			}, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async checkinFile(params, sessionId) {
+			return proxy('checkin_file', params as Record<string, unknown>, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async getFileCheckouts(projectId, options) {
+			return proxy('get_file_checkouts', {
+				project_id: projectId,
+				...options
+			});
+		},
+
+		async abandonCheckout(params) {
+			return proxy('abandon_checkout', params as Record<string, unknown>);
+		},
+
+		async getFileCheckoutsStats(projectId) {
+			return proxy('get_file_checkouts_stats', { project_id: projectId });
+		},
+
+		async isFileAvailable(projectId, filePath) {
+			return proxy('is_file_available', {
+				project_id: projectId,
+				file_path: filePath
+			});
+		}
+	};
+}

package/src/api-client/git-issues.ts

@@ -0,0 +1,88 @@
+/**
+ * Git Issues API Methods
+ *
+ * Methods for git issue tracking:
+ * - addGitIssue: Record a git-related issue
+ * - resolveGitIssue: Mark a git issue as resolved
+ * - getGitIssues: List git issues for a project
+ * - deleteGitIssue: Delete a git issue
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface GitIssuesMethods {
+	addGitIssue(projectId: string, params: {
+		issue_type: string;
+		branch: string;
+		target_branch?: string;
+		pr_url?: string;
+		conflicting_files?: string[];
+		error_message?: string;
+		task_id?: string;
+	}, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		git_issue_id: string;
+	}>>;
+
+	resolveGitIssue(gitIssueId: string, params?: {
+		resolution_note?: string;
+		auto_resolved?: boolean;
+	}, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		git_issue_id: string;
+	}>>;
+
+	getGitIssues(projectId: string, params?: {
+		status?: string;
+		issue_type?: string;
+		branch?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		git_issues: Array<{
+			id: string;
+			issue_type: string;
+			branch: string;
+			target_branch?: string;
+			pr_url?: string;
+			conflicting_files?: string[];
+			error_message?: string;
+			status: string;
+			created_at: string;
+			resolved_at?: string;
+		}>;
+	}>>;
+
+	deleteGitIssue(gitIssueId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+}
+
+export function createGitIssuesMethods(proxy: ProxyFn): GitIssuesMethods {
+	return {
+		async addGitIssue(projectId, params, sessionId) {
+			return proxy('add_git_issue', {
+				project_id: projectId,
+				...params
+			}, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async resolveGitIssue(gitIssueId, params, sessionId) {
+			return proxy('resolve_git_issue', {
+				git_issue_id: gitIssueId,
+				...params
+			}, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async getGitIssues(projectId, params) {
+			return proxy('get_git_issues', {
+				project_id: projectId,
+				...params
+			});
+		},
+
+		async deleteGitIssue(gitIssueId) {
+			return proxy('delete_git_issue', { git_issue_id: gitIssueId });
+		}
+	};
+}

package/src/api-client/index.ts

@@ -21,6 +21,17 @@ import { createFindingsMethods, type FindingsMethods } from './findings.js';
 import { createMilestonesMethods, type MilestonesMethods } from './milestones.js';
 import { createValidationMethods, type ValidationMethods } from './validation.js';
 import { createFallbackMethods, type FallbackMethods } from './fallback.js';
+import { createRequestsMethods, type RequestsMethods } from './requests.js';
+import { createDeploymentMethods, type DeploymentMethods } from './deployment.js';
+import { createOrganizationsMethods, type OrganizationsMethods } from './organizations.js';
+import { createBodiesOfWorkMethods, type BodiesOfWorkMethods } from './bodies-of-work.js';
+import { createGitIssuesMethods, type GitIssuesMethods } from './git-issues.js';
+import { createFileCheckoutsMethods, type FileCheckoutsMethods } from './file-checkouts.js';
+import { createConnectorsMethods, type ConnectorsMethods } from './connectors.js';
+import { createSprintsMethods, type SprintsMethods } from './sprints.js';
+import { createSubtasksMethods, type SubtasksMethods } from './subtasks.js';
+import { createProgressMethods, type ProgressMethods } from './progress.js';
+import { createChatMethods, type ChatMethods } from './chat.js';
 
 // Re-export types
 export type { ApiClientConfig, ApiResponse, RetryConfig, RequestFn, ProxyFn } from './types.js';
@@ -37,6 +48,17 @@ export type { FindingsMethods } from './findings.js';
 export type { MilestonesMethods } from './milestones.js';
 export type { ValidationMethods } from './validation.js';
 export type { FallbackMethods } from './fallback.js';
+export type { RequestsMethods } from './requests.js';
+export type { DeploymentMethods } from './deployment.js';
+export type { OrganizationsMethods } from './organizations.js';
+export type { BodiesOfWorkMethods } from './bodies-of-work.js';
+export type { GitIssuesMethods } from './git-issues.js';
+export type { FileCheckoutsMethods } from './file-checkouts.js';
+export type { ConnectorsMethods } from './connectors.js';
+export type { SprintsMethods } from './sprints.js';
+export type { SubtasksMethods } from './subtasks.js';
+export type { ProgressMethods } from './progress.js';
+export type { ChatMethods } from './chat.js';
 
 const DEFAULT_API_URL = 'https://vibescope.dev';
 
@@ -86,7 +108,18 @@ export interface VibescopeApiClientMethods
 		FindingsMethods,
 		MilestonesMethods,
 		ValidationMethods,
-		FallbackMethods {}
+		FallbackMethods,
+		RequestsMethods,
+		DeploymentMethods,
+		OrganizationsMethods,
+		BodiesOfWorkMethods,
+		GitIssuesMethods,
+		FileCheckoutsMethods,
+		ConnectorsMethods,
+		SprintsMethods,
+		SubtasksMethods,
+		ProgressMethods,
+		ChatMethods {}
 
 export class VibescopeApiClient implements VibescopeApiClientMethods {
 	private apiKey: string;
@@ -107,6 +140,17 @@ export class VibescopeApiClient implements VibescopeApiClientMethods {
 	private milestonesMethods: MilestonesMethods;
 	private validationMethods: ValidationMethods;
 	private fallbackMethods: FallbackMethods;
+	private requestsMethods: RequestsMethods;
+	private deploymentMethods: DeploymentMethods;
+	private organizationsMethods: OrganizationsMethods;
+	private bodiesOfWorkMethods: BodiesOfWorkMethods;
+	private gitIssuesMethods: GitIssuesMethods;
+	private fileCheckoutsMethods: FileCheckoutsMethods;
+	private connectorsMethods: ConnectorsMethods;
+	private sprintsMethods: SprintsMethods;
+	private subtasksMethods: SubtasksMethods;
+	private progressMethods: ProgressMethods;
+	private chatMethods: ChatMethods;
 
 	constructor(config: ApiClientConfig) {
 		this.apiKey = config.apiKey;
@@ -137,6 +181,17 @@ export class VibescopeApiClient implements VibescopeApiClientMethods {
 		this.milestonesMethods = createMilestonesMethods(proxy);
 		this.validationMethods = createValidationMethods(proxy);
 		this.fallbackMethods = createFallbackMethods(proxy);
+		this.requestsMethods = createRequestsMethods(proxy);
+		this.deploymentMethods = createDeploymentMethods(proxy);
+		this.organizationsMethods = createOrganizationsMethods(proxy);
+		this.bodiesOfWorkMethods = createBodiesOfWorkMethods(proxy);
+		this.gitIssuesMethods = createGitIssuesMethods(proxy);
+		this.fileCheckoutsMethods = createFileCheckoutsMethods(proxy);
+		this.connectorsMethods = createConnectorsMethods(proxy);
+		this.sprintsMethods = createSprintsMethods(proxy);
+		this.subtasksMethods = createSubtasksMethods(proxy);
+		this.progressMethods = createProgressMethods(request, proxy);
+		this.chatMethods = createChatMethods(proxy);
 	}
 
 	private async request<T>(method: string, path: string, body?: unknown): Promise<ApiResponse<T>> {
@@ -357,19 +412,130 @@ export class VibescopeApiClient implements VibescopeApiClientMethods {
 	stopFallbackActivity = (projectId: string, summary?: string, sessionId?: string) => this.fallbackMethods.stopFallbackActivity(projectId, summary, sessionId);
 
 	// ============================================================================
-	// TODO: Additional methods to be migrated from original api-client.ts
-	// The following domains need to be split into separate files:
-	// - requests.ts (getPendingRequests, answerQuestion, etc.)
-	// - deployment.ts (requestDeployment, startDeployment, etc.)
-	// - organizations.ts (listOrganizations, etc.)
-	// - bodies-of-work.ts (createBodyOfWork, etc.)
-	// - git-issues.ts (addGitIssue, etc.)
-	// - file-checkouts.ts (checkoutFile, checkinFile, etc.)
-	// - connectors.ts (getConnectors, addConnector, etc.)
-	// - sprints.ts (getSprints, createSprint, etc.)
-	// - subtasks.ts (addSubtask, getSubtasks)
-	// - progress.ts (logProgress, getActivityHistory, etc.)
+	// Requests methods (delegated)
 	// ============================================================================
+	getPendingRequests = (projectId: string, sessionId?: string, limit?: number, offset?: number) => this.requestsMethods.getPendingRequests(projectId, sessionId, limit, offset);
+	acknowledgeRequest = (requestId: string, sessionId?: string) => this.requestsMethods.acknowledgeRequest(requestId, sessionId);
+	answerQuestion = (requestId: string, answer: string, sessionId?: string) => this.requestsMethods.answerQuestion(requestId, answer, sessionId);
+
+	// ============================================================================
+	// Deployment methods (delegated)
+	// ============================================================================
+	requestDeployment = (projectId: string, params?: Parameters<DeploymentMethods['requestDeployment']>[1], sessionId?: string) => this.deploymentMethods.requestDeployment(projectId, params, sessionId);
+	checkDeploymentStatus = (projectId: string) => this.deploymentMethods.checkDeploymentStatus(projectId);
+	claimDeploymentValidation = (projectId: string, sessionId?: string) => this.deploymentMethods.claimDeploymentValidation(projectId, sessionId);
+	reportValidation = (projectId: string, params: Parameters<DeploymentMethods['reportValidation']>[1]) => this.deploymentMethods.reportValidation(projectId, params);
+	startDeployment = (projectId: string, sessionId?: string) => this.deploymentMethods.startDeployment(projectId, sessionId);
+	completeDeployment = (projectId: string, params: Parameters<DeploymentMethods['completeDeployment']>[1]) => this.deploymentMethods.completeDeployment(projectId, params);
+	cancelDeployment = (projectId: string, reason?: string) => this.deploymentMethods.cancelDeployment(projectId, reason);
+	addDeploymentRequirement = (projectId: string, params: Parameters<DeploymentMethods['addDeploymentRequirement']>[1]) => this.deploymentMethods.addDeploymentRequirement(projectId, params);
+	getDeploymentRequirements = (projectId: string, params?: Parameters<DeploymentMethods['getDeploymentRequirements']>[1]) => this.deploymentMethods.getDeploymentRequirements(projectId, params);
+	getDeploymentRequirementsStats = (projectId: string) => this.deploymentMethods.getDeploymentRequirementsStats(projectId);
+	completeDeploymentRequirement = (requirementId: string) => this.deploymentMethods.completeDeploymentRequirement(requirementId);
+	reorderDeploymentRequirements = (projectId: string, params: Parameters<DeploymentMethods['reorderDeploymentRequirements']>[1]) => this.deploymentMethods.reorderDeploymentRequirements(projectId, params);
+	scheduleDeployment = (projectId: string, params: Parameters<DeploymentMethods['scheduleDeployment']>[1]) => this.deploymentMethods.scheduleDeployment(projectId, params);
+	getScheduledDeployments = (projectId: string, params?: Parameters<DeploymentMethods['getScheduledDeployments']>[1]) => this.deploymentMethods.getScheduledDeployments(projectId, params);
+	updateScheduledDeployment = (scheduleId: string, updates: Parameters<DeploymentMethods['updateScheduledDeployment']>[1]) => this.deploymentMethods.updateScheduledDeployment(scheduleId, updates);
+	deleteScheduledDeployment = (scheduleId: string) => this.deploymentMethods.deleteScheduledDeployment(scheduleId);
+	triggerScheduledDeployment = (scheduleId: string, sessionId?: string) => this.deploymentMethods.triggerScheduledDeployment(scheduleId, sessionId);
+	checkDueDeployments = (projectId: string) => this.deploymentMethods.checkDueDeployments(projectId);
+
+	// ============================================================================
+	// Organizations methods (delegated)
+	// ============================================================================
+	listOrganizations = () => this.organizationsMethods.listOrganizations();
+	createOrganization = (params: Parameters<OrganizationsMethods['createOrganization']>[0]) => this.organizationsMethods.createOrganization(params);
+	updateOrganization = (organizationId: string, updates: Parameters<OrganizationsMethods['updateOrganization']>[1]) => this.organizationsMethods.updateOrganization(organizationId, updates);
+	deleteOrganization = (organizationId: string) => this.organizationsMethods.deleteOrganization(organizationId);
+	listOrgMembers = (organizationId: string) => this.organizationsMethods.listOrgMembers(organizationId);
+	inviteMember = (organizationId: string, email: string, role?: string) => this.organizationsMethods.inviteMember(organizationId, email, role);
+	updateMemberRole = (organizationId: string, userId: string, role: string) => this.organizationsMethods.updateMemberRole(organizationId, userId, role);
+	removeMember = (organizationId: string, userId: string) => this.organizationsMethods.removeMember(organizationId, userId);
+	leaveOrganization = (organizationId: string) => this.organizationsMethods.leaveOrganization(organizationId);
+	shareProjectWithOrg = (projectId: string, organizationId: string, permission?: string) => this.organizationsMethods.shareProjectWithOrg(projectId, organizationId, permission);
+	unshareProject = (projectId: string, organizationId: string) => this.organizationsMethods.unshareProject(projectId, organizationId);
+	updateProjectShare = (projectId: string, organizationId: string, permission: string) => this.organizationsMethods.updateProjectShare(projectId, organizationId, permission);
+	listProjectShares = (projectId: string) => this.organizationsMethods.listProjectShares(projectId);
+
+	// ============================================================================
+	// Bodies of work methods (delegated)
+	// ============================================================================
+	createBodyOfWork = (projectId: string, params: Parameters<BodiesOfWorkMethods['createBodyOfWork']>[1]) => this.bodiesOfWorkMethods.createBodyOfWork(projectId, params);
+	getBodyOfWork = (bodyOfWorkId: string) => this.bodiesOfWorkMethods.getBodyOfWork(bodyOfWorkId);
+	getBodiesOfWork = (projectId: string, params?: Parameters<BodiesOfWorkMethods['getBodiesOfWork']>[1]) => this.bodiesOfWorkMethods.getBodiesOfWork(projectId, params);
+	updateBodyOfWork = (bodyOfWorkId: string, updates: Parameters<BodiesOfWorkMethods['updateBodyOfWork']>[1]) => this.bodiesOfWorkMethods.updateBodyOfWork(bodyOfWorkId, updates);
+	deleteBodyOfWork = (bodyOfWorkId: string) => this.bodiesOfWorkMethods.deleteBodyOfWork(bodyOfWorkId);
+	addTaskToBodyOfWork = (bodyOfWorkId: string, taskId: string, phase?: string, orderIndex?: number) => this.bodiesOfWorkMethods.addTaskToBodyOfWork(bodyOfWorkId, taskId, phase, orderIndex);
+	removeTaskFromBodyOfWork = (taskId: string) => this.bodiesOfWorkMethods.removeTaskFromBodyOfWork(taskId);
+	activateBodyOfWork = (bodyOfWorkId: string) => this.bodiesOfWorkMethods.activateBodyOfWork(bodyOfWorkId);
+	addTaskDependency = (bodyOfWorkId: string, taskId: string, dependsOnTaskId: string) => this.bodiesOfWorkMethods.addTaskDependency(bodyOfWorkId, taskId, dependsOnTaskId);
+	removeTaskDependency = (taskId: string, dependsOnTaskId: string) => this.bodiesOfWorkMethods.removeTaskDependency(taskId, dependsOnTaskId);
+	getTaskDependencies = (params: Parameters<BodiesOfWorkMethods['getTaskDependencies']>[0]) => this.bodiesOfWorkMethods.getTaskDependencies(params);
+	getNextBodyOfWorkTask = (bodyOfWorkId: string) => this.bodiesOfWorkMethods.getNextBodyOfWorkTask(bodyOfWorkId);
+
+	// ============================================================================
+	// Git issues methods (delegated)
+	// ============================================================================
+	addGitIssue = (projectId: string, params: Parameters<GitIssuesMethods['addGitIssue']>[1], sessionId?: string) => this.gitIssuesMethods.addGitIssue(projectId, params, sessionId);
+	resolveGitIssue = (gitIssueId: string, params?: Parameters<GitIssuesMethods['resolveGitIssue']>[1], sessionId?: string) => this.gitIssuesMethods.resolveGitIssue(gitIssueId, params, sessionId);
+	getGitIssues = (projectId: string, params?: Parameters<GitIssuesMethods['getGitIssues']>[1]) => this.gitIssuesMethods.getGitIssues(projectId, params);
+	deleteGitIssue = (gitIssueId: string) => this.gitIssuesMethods.deleteGitIssue(gitIssueId);
+
+	// ============================================================================
+	// File checkouts methods (delegated)
+	// ============================================================================
+	checkoutFile = (projectId: string, filePath: string, reason?: string, sessionId?: string) => this.fileCheckoutsMethods.checkoutFile(projectId, filePath, reason, sessionId);
+	checkinFile = (params: Parameters<FileCheckoutsMethods['checkinFile']>[0], sessionId?: string) => this.fileCheckoutsMethods.checkinFile(params, sessionId);
+	getFileCheckouts = (projectId: string, options?: Parameters<FileCheckoutsMethods['getFileCheckouts']>[1]) => this.fileCheckoutsMethods.getFileCheckouts(projectId, options);
+	abandonCheckout = (params: Parameters<FileCheckoutsMethods['abandonCheckout']>[0]) => this.fileCheckoutsMethods.abandonCheckout(params);
+	getFileCheckoutsStats = (projectId: string) => this.fileCheckoutsMethods.getFileCheckoutsStats(projectId);
+	isFileAvailable = (projectId: string, filePath: string) => this.fileCheckoutsMethods.isFileAvailable(projectId, filePath);
+
+	// ============================================================================
+	// Connectors methods (delegated)
+	// ============================================================================
+	getConnectors = (projectId: string, params?: Parameters<ConnectorsMethods['getConnectors']>[1]) => this.connectorsMethods.getConnectors(projectId, params);
+	getConnector = (connectorId: string) => this.connectorsMethods.getConnector(connectorId);
+	addConnector = (projectId: string, params: Parameters<ConnectorsMethods['addConnector']>[1]) => this.connectorsMethods.addConnector(projectId, params);
+	updateConnector = (connectorId: string, updates: Parameters<ConnectorsMethods['updateConnector']>[1]) => this.connectorsMethods.updateConnector(connectorId, updates);
+	deleteConnector = (connectorId: string) => this.connectorsMethods.deleteConnector(connectorId);
+	testConnector = (connectorId: string) => this.connectorsMethods.testConnector(connectorId);
+	getConnectorEvents = (params: Parameters<ConnectorsMethods['getConnectorEvents']>[0]) => this.connectorsMethods.getConnectorEvents(params);
+
+	// ============================================================================
+	// Sprints methods (delegated)
+	// ============================================================================
+	createSprint = (projectId: string, params: Parameters<SprintsMethods['createSprint']>[1]) => this.sprintsMethods.createSprint(projectId, params);
+	updateSprint = (sprintId: string, updates: Parameters<SprintsMethods['updateSprint']>[1]) => this.sprintsMethods.updateSprint(sprintId, updates);
+	getSprint = (sprintId: string, summaryOnly?: boolean) => this.sprintsMethods.getSprint(sprintId, summaryOnly);
+	getSprints = (projectId: string, params?: Parameters<SprintsMethods['getSprints']>[1]) => this.sprintsMethods.getSprints(projectId, params);
+	deleteSprint = (sprintId: string) => this.sprintsMethods.deleteSprint(sprintId);
+	startSprint = (sprintId: string) => this.sprintsMethods.startSprint(sprintId);
+	completeSprint = (sprintId: string, params?: Parameters<SprintsMethods['completeSprint']>[1]) => this.sprintsMethods.completeSprint(sprintId, params);
+	addTaskToSprint = (sprintId: string, taskId: string, params?: Parameters<SprintsMethods['addTaskToSprint']>[2]) => this.sprintsMethods.addTaskToSprint(sprintId, taskId, params);
+	removeTaskFromSprint = (sprintId: string, taskId: string) => this.sprintsMethods.removeTaskFromSprint(sprintId, taskId);
+	getSprintBacklog = (projectId: string, sprintId?: string, params?: Parameters<SprintsMethods['getSprintBacklog']>[2]) => this.sprintsMethods.getSprintBacklog(projectId, sprintId, params);
+	getSprintVelocity = (projectId: string, limit?: number) => this.sprintsMethods.getSprintVelocity(projectId, limit);
+
+	// ============================================================================
+	// Subtasks methods (delegated)
+	// ============================================================================
+	addSubtask = (parentTaskId: string, params: Parameters<SubtasksMethods['addSubtask']>[1], sessionId?: string) => this.subtasksMethods.addSubtask(parentTaskId, params, sessionId);
+	getSubtasks = (parentTaskId: string, status?: string) => this.subtasksMethods.getSubtasks(parentTaskId, status);
+
+	// ============================================================================
+	// Progress methods (delegated)
+	// ============================================================================
+	logProgress = (projectId: string, params: Parameters<ProgressMethods['logProgress']>[1]) => this.progressMethods.logProgress(projectId, params);
+	getActivityFeed = (projectId: string, params?: Parameters<ProgressMethods['getActivityFeed']>[1]) => this.progressMethods.getActivityFeed(projectId, params);
+	getActivityHistory = (projectId: string, params?: Parameters<ProgressMethods['getActivityHistory']>[1]) => this.progressMethods.getActivityHistory(projectId, params);
+	getActivitySchedules = (projectId: string, params?: Parameters<ProgressMethods['getActivitySchedules']>[1]) => this.progressMethods.getActivitySchedules(projectId, params);
+
+	// ============================================================================
+	// Chat methods (delegated)
+	// ============================================================================
+	sendProjectMessage = (projectId: string, message: string, sessionId?: string) => this.chatMethods.sendProjectMessage(projectId, message, sessionId);
+	getProjectMessages = (projectId: string, limit?: number) => this.chatMethods.getProjectMessages(projectId, limit);
 }
 
 // Singleton instance

package/src/api-client/organizations.ts

@@ -0,0 +1,185 @@
+/**
+ * Organizations API Methods
+ *
+ * Methods for organization management:
+ * - listOrganizations: List user's organizations
+ * - createOrganization: Create a new organization
+ * - updateOrganization: Update organization details
+ * - deleteOrganization: Delete an organization
+ * - listOrgMembers: List organization members
+ * - inviteMember: Invite a user to an organization
+ * - updateMemberRole: Change a member's role
+ * - removeMember: Remove a member
+ * - leaveOrganization: Leave an organization
+ * - shareProjectWithOrg: Share a project with an organization
+ * - unshareProject: Remove a project share
+ * - updateProjectShare: Update project share permission
+ * - listProjectShares: List project shares
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface OrganizationsMethods {
+	listOrganizations(): Promise<ApiResponse<{
+		organizations: Array<{
+			id: string;
+			name: string;
+			slug: string;
+			description?: string;
+			role: string;
+		}>;
+	}>>;
+
+	createOrganization(params: {
+		name: string;
+		slug?: string;
+		description?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		organization: { id: string; name: string; slug: string };
+	}>>;
+
+	updateOrganization(organizationId: string, updates: {
+		name?: string;
+		description?: string;
+		logo_url?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		organization_id: string;
+	}>>;
+
+	deleteOrganization(organizationId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	listOrgMembers(organizationId: string): Promise<ApiResponse<{
+		members: Array<{
+			user_id: string;
+			email: string;
+			role: string;
+			joined_at: string;
+		}>;
+	}>>;
+
+	inviteMember(organizationId: string, email: string, role?: string): Promise<ApiResponse<{
+		success: boolean;
+		invite_id: string;
+	}>>;
+
+	updateMemberRole(organizationId: string, userId: string, role: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	removeMember(organizationId: string, userId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	leaveOrganization(organizationId: string): Promise<ApiResponse<{
+		success: boolean;
+		message: string;
+	}>>;
+
+	shareProjectWithOrg(projectId: string, organizationId: string, permission?: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	unshareProject(projectId: string, organizationId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	updateProjectShare(projectId: string, organizationId: string, permission: string): Promise<ApiResponse<{
+		success: boolean;
+		share: { permission: string };
+	}>>;
+
+	listProjectShares(projectId: string): Promise<ApiResponse<{
+		shares: Array<{
+			id: string;
+			permission: string;
+			shared_at: string;
+			organization: { id: string; name: string; slug: string };
+		}>;
+		count: number;
+	}>>;
+}
+
+export function createOrganizationsMethods(proxy: ProxyFn): OrganizationsMethods {
+	return {
+		async listOrganizations() {
+			return proxy('list_organizations', {});
+		},
+
+		async createOrganization(params) {
+			return proxy('create_organization', params);
+		},
+
+		async updateOrganization(organizationId, updates) {
+			return proxy('update_organization', {
+				organization_id: organizationId,
+				...updates
+			});
+		},
+
+		async deleteOrganization(organizationId) {
+			return proxy('delete_organization', { organization_id: organizationId });
+		},
+
+		async listOrgMembers(organizationId) {
+			return proxy('list_org_members', { organization_id: organizationId });
+		},
+
+		async inviteMember(organizationId, email, role) {
+			return proxy('invite_member', {
+				organization_id: organizationId,
+				email,
+				role
+			});
+		},
+
+		async updateMemberRole(organizationId, userId, role) {
+			return proxy('update_member_role', {
+				organization_id: organizationId,
+				user_id: userId,
+				role
+			});
+		},
+
+		async removeMember(organizationId, userId) {
+			return proxy('remove_member', {
+				organization_id: organizationId,
+				user_id: userId
+			});
+		},
+
+		async leaveOrganization(organizationId) {
+			return proxy('leave_organization', { organization_id: organizationId });
+		},
+
+		async shareProjectWithOrg(projectId, organizationId, permission) {
+			return proxy('share_project_with_org', {
+				project_id: projectId,
+				organization_id: organizationId,
+				permission
+			});
+		},
+
+		async unshareProject(projectId, organizationId) {
+			return proxy('unshare_project', {
+				project_id: projectId,
+				organization_id: organizationId
+			});
+		},
+
+		async updateProjectShare(projectId, organizationId, permission) {
+			return proxy('update_project_share', {
+				project_id: projectId,
+				organization_id: organizationId,
+				permission
+			});
+		},
+
+		async listProjectShares(projectId) {
+			return proxy('list_project_shares', { project_id: projectId });
+		}
+	};
+}