projects-plus-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,771 @@
+'use strict';
+
+// src/errors/index.ts
+var ApiError = class _ApiError extends Error {
+  constructor(message, status, code, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "ApiError";
+    Object.setPrototypeOf(this, _ApiError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends ApiError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, 401, "AUTHENTICATION_ERROR");
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends ApiError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, 429, "RATE_LIMIT_ERROR");
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends ApiError {
+  constructor(message = "Resource not found") {
+    super(message, 404, "NOT_FOUND_ERROR");
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends ApiError {
+  constructor(message = "Invalid request", details) {
+    super(message, 400, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var ServerError = class _ServerError extends ApiError {
+  constructor(message = "Server error") {
+    super(message, 500, "SERVER_ERROR");
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends ApiError {
+  constructor(message = "Request timed out") {
+    super(message, 408, "TIMEOUT_ERROR");
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends ApiError {
+  constructor(message = "Network error") {
+    super(message, 0, "NETWORK_ERROR");
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+function createApiError(status, message, details) {
+  switch (status) {
+    case 401:
+      return new AuthenticationError(message);
+    case 404:
+      return new NotFoundError(message);
+    case 429:
+      return new RateLimitError(message);
+    case 400:
+      return new ValidationError(message, details);
+    case 408:
+      return new TimeoutError(message);
+    default:
+      if (status >= 500) {
+        return new ServerError(message);
+      }
+      return new ApiError(message, status, void 0, details);
+  }
+}
+
+// src/utils/http.ts
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Make an HTTP request with automatic retries
+   */
+  async request(path, options = {}) {
+    const { method = "GET", body, params, headers = {}, skipRetry = false } = options;
+    const url = this.buildUrl(path, params);
+    const requestInit = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey,
+        ...headers
+      }
+    };
+    if (body !== void 0) {
+      requestInit.body = JSON.stringify(body);
+    }
+    const maxAttempts = skipRetry ? 1 : this.config.retries;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, requestInit);
+        return await this.handleResponse(response);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof AuthenticationError || error instanceof ApiError && error.status < 500) {
+          throw error;
+        }
+        if (attempt < maxAttempts) {
+          const delay = this.calculateRetryDelay(attempt, error);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new NetworkError("Request failed after retries");
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(path, this.config.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${this.config.timeout}ms`);
+      }
+      throw new NetworkError(
+        error instanceof Error ? error.message : "Network error"
+      );
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Handle response and parse JSON
+   */
+  async handleResponse(response) {
+    let data;
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      try {
+        data = await response.json();
+      } catch {
+        data = null;
+      }
+    } else {
+      data = await response.text();
+    }
+    if (!response.ok) {
+      const message = this.extractErrorMessage(data) ?? response.statusText;
+      if (response.status === 429) {
+        const retryAfter = parseInt(
+          response.headers.get("Retry-After") ?? "60",
+          10
+        );
+        throw new RateLimitError(message, retryAfter);
+      }
+      throw createApiError(response.status, message, data);
+    }
+    return data;
+  }
+  /**
+   * Extract error message from response data
+   */
+  extractErrorMessage(data) {
+    if (typeof data === "string") return data;
+    if (typeof data === "object" && data !== null) {
+      const obj = data;
+      if (typeof obj["error"] === "string") return obj["error"];
+      if (typeof obj["message"] === "string") return obj["message"];
+    }
+    return void 0;
+  }
+  /**
+   * Calculate retry delay with exponential backoff
+   */
+  calculateRetryDelay(attempt, error) {
+    if (error instanceof RateLimitError && error.retryAfter) {
+      return error.retryAfter * 1e3;
+    }
+    return this.config.retryDelay * Math.pow(2, attempt - 1);
+  }
+  /**
+   * Sleep for the specified duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/resources/context.ts
+var ContextResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get theme context including all projects and tasks
+   *
+   * @example
+   * ```ts
+   * const context = await pp.context.get();
+   * console.log(context.theme.name);
+   * console.log(context.projects);
+   * ```
+   */
+  async get() {
+    const response = await this.http.request("/context");
+    return response.context;
+  }
+};
+
+// src/resources/sessions.ts
+var SessionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Start a new AI development session
+   *
+   * @param params - Session parameters
+   * @returns The created session
+   *
+   * @example
+   * ```ts
+   * const session = await pp.sessions.start({ ai: 'claude' });
+   * console.log(session.id);
+   * ```
+   */
+  async start(params) {
+    const response = await this.http.request(
+      "/sessions/start",
+      {
+        method: "POST",
+        body: params
+      }
+    );
+    return response.session;
+  }
+  /**
+   * End the current AI development session
+   *
+   * @param params - Optional handoff note
+   * @returns The ended session
+   *
+   * @example
+   * ```ts
+   * const session = await pp.sessions.end({
+   *   handoffNote: 'Completed tasks X, Y, Z. Remaining: A, B.'
+   * });
+   * ```
+   */
+  async end(params) {
+    const response = await this.http.request(
+      "/sessions/end",
+      {
+        method: "POST",
+        body: params ?? {}
+      }
+    );
+    return response.session;
+  }
+  /**
+   * Get the current active session if any
+   *
+   * @returns The current session or null
+   */
+  async current() {
+    try {
+      const response = await this.http.request(
+        "/sessions/current"
+      );
+      return response.session;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/resources/tasks.ts
+var TasksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List tasks with optional filters
+   *
+   * @param params - Filter parameters
+   * @returns List of tasks
+   *
+   * @example
+   * ```ts
+   * // Get all active tasks
+   * const tasks = await pp.tasks.list({ status: 'active' });
+   *
+   * // Get tasks for a specific project
+   * const projectTasks = await pp.tasks.list({
+   *   projectId: 'proj-123',
+   *   status: 'active'
+   * });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.request("/tasks", {
+      params
+    });
+    return response.tasks;
+  }
+  /**
+   * Get a specific task
+   *
+   * @param taskId - Task ID
+   * @param params - Additional parameters (projectId required)
+   * @returns The task
+   *
+   * @example
+   * ```ts
+   * const task = await pp.tasks.get('task-123', {
+   *   projectId: 'proj-123'
+   * });
+   * ```
+   */
+  async get(taskId, params) {
+    const response = await this.http.request(
+      `/tasks/${taskId}`,
+      {
+        params: {
+          projectId: params.projectId
+        }
+      }
+    );
+    return response.task;
+  }
+  /**
+   * Mark a task as completed (archived)
+   *
+   * @param taskId - Task ID
+   * @param params - Additional parameters (projectId required)
+   * @returns The updated task
+   *
+   * @example
+   * ```ts
+   * await pp.tasks.complete('task-123', {
+   *   projectId: 'proj-123'
+   * });
+   * ```
+   */
+  async complete(taskId, params) {
+    const response = await this.http.request(
+      `/tasks/${taskId}/complete`,
+      {
+        method: "POST",
+        body: params
+      }
+    );
+    return response.task;
+  }
+  /**
+   * Update task status
+   *
+   * @param taskId - Task ID
+   * @param params - Status and projectId
+   * @returns The updated task
+   *
+   * @example
+   * ```ts
+   * await pp.tasks.updateStatus('task-123', {
+   *   projectId: 'proj-123',
+   *   status: 'paused'
+   * });
+   * ```
+   */
+  async updateStatus(taskId, params) {
+    const response = await this.http.request(
+      `/tasks/${taskId}/status`,
+      {
+        method: "PATCH",
+        body: params
+      }
+    );
+    return response.task;
+  }
+};
+
+// src/resources/projects.ts
+var ProjectsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all projects
+   *
+   * @param params - Filter parameters
+   * @returns List of projects
+   *
+   * @example
+   * ```ts
+   * const projects = await pp.projects.list();
+   *
+   * // Filter by status
+   * const activeProjects = await pp.projects.list({ status: 'active' });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.request("/projects", {
+      params
+    });
+    return response.projects;
+  }
+  /**
+   * Get a specific project
+   *
+   * @param projectId - Project ID
+   * @returns The project
+   *
+   * @example
+   * ```ts
+   * const project = await pp.projects.get('proj-123');
+   * ```
+   */
+  async get(projectId) {
+    const response = await this.http.request(
+      `/projects/${projectId}`
+    );
+    return response.project;
+  }
+  /**
+   * Get tasks for a specific project
+   *
+   * @param projectId - Project ID
+   * @param params - Filter parameters
+   * @returns List of tasks
+   *
+   * @example
+   * ```ts
+   * const tasks = await pp.projects.getTasks('proj-123');
+   *
+   * // Filter by status
+   * const activeTasks = await pp.projects.getTasks('proj-123', {
+   *   status: 'active'
+   * });
+   * ```
+   */
+  async getTasks(projectId, params) {
+    const response = await this.http.request(
+      `/projects/${projectId}/tasks`,
+      {
+        params
+      }
+    );
+    return response.tasks;
+  }
+};
+
+// src/resources/comments.ts
+var CommentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List comments for a task
+   *
+   * @param params - Task identifiers
+   * @returns List of comments
+   *
+   * @example
+   * ```ts
+   * const comments = await pp.comments.list({
+   *   projectId: 'proj-123',
+   *   taskId: 'task-123'
+   * });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.request(
+      "/comments",
+      {
+        params: {
+          projectId: params.projectId,
+          taskId: params.taskId
+        }
+      }
+    );
+    return response.comments;
+  }
+  /**
+   * Create a new comment on a task
+   *
+   * @param params - Comment data
+   * @returns The created comment
+   *
+   * @example
+   * ```ts
+   * await pp.comments.create({
+   *   projectId: 'proj-123',
+   *   taskId: 'task-123',
+   *   content: '## 実装完了\n\n### 変更内容\n- file1.ts\n- file2.ts',
+   *   aiName: 'Claude'
+   * });
+   * ```
+   */
+  async create(params) {
+    const response = await this.http.request(
+      "/comments",
+      {
+        method: "POST",
+        body: params
+      }
+    );
+    return response.comment;
+  }
+  /**
+   * Delete a comment
+   *
+   * @param commentId - Comment ID
+   * @param params - Task identifiers
+   *
+   * @example
+   * ```ts
+   * await pp.comments.delete('comment-123', {
+   *   projectId: 'proj-123',
+   *   taskId: 'task-123'
+   * });
+   * ```
+   */
+  async delete(commentId, params) {
+    await this.http.request(`/comments/${commentId}`, {
+      method: "DELETE",
+      params: {
+        projectId: params.projectId,
+        taskId: params.taskId
+      }
+    });
+  }
+};
+
+// src/workflow.ts
+var Workflow = class {
+  client;
+  ai;
+  currentSession = null;
+  currentContext = null;
+  constructor(client, ai) {
+    this.client = client;
+    this.ai = ai;
+  }
+  /**
+   * Start session and get context in one call
+   *
+   * @returns Session and context
+   */
+  async start() {
+    const session = await this.client.sessions.start({ ai: this.ai });
+    const context = await this.client.context.get();
+    this.currentSession = session;
+    this.currentContext = context;
+    return { session, context };
+  }
+  /**
+   * Report progress with auto-formatted markdown comment
+   *
+   * @param taskId - Task ID
+   * @param params - Progress details
+   */
+  async reportProgress(taskId, params) {
+    const content = this.formatProgressComment(params);
+    await this.client.comments.create({
+      projectId: params.projectId,
+      taskId,
+      content,
+      aiName: this.ai.charAt(0).toUpperCase() + this.ai.slice(1)
+      // Capitalize
+    });
+  }
+  /**
+   * Complete a task and refresh context
+   *
+   * @param taskId - Task ID
+   * @param params - Project ID
+   * @returns Updated context
+   */
+  async completeAndRefresh(taskId, params) {
+    await this.client.tasks.complete(taskId, params);
+    const context = await this.client.context.get();
+    this.currentContext = context;
+    return context;
+  }
+  /**
+   * Refresh context without completing a task
+   *
+   * @returns Updated context
+   */
+  async refresh() {
+    const context = await this.client.context.get();
+    this.currentContext = context;
+    return context;
+  }
+  /**
+   * End the session with optional handoff note
+   *
+   * @param handoffNote - Summary for next session
+   * @returns Ended session
+   */
+  async end(handoffNote) {
+    const session = await this.client.sessions.end({ handoffNote });
+    this.currentSession = session;
+    return session;
+  }
+  /**
+   * Get the current session
+   */
+  getSession() {
+    return this.currentSession;
+  }
+  /**
+   * Get the current context
+   */
+  getContext() {
+    return this.currentContext;
+  }
+  /**
+   * Format a progress comment from params
+   */
+  formatProgressComment(params) {
+    const lines = ["## \u5B9F\u88C5\u5B8C\u4E86", ""];
+    if (params.changes && params.changes.length > 0) {
+      lines.push("### \u5909\u66F4\u5185\u5BB9");
+      for (const change of params.changes) {
+        lines.push(`- \`${change}\``);
+      }
+      lines.push("");
+    }
+    if (params.testResults) {
+      lines.push("### \u30C6\u30B9\u30C8\u7D50\u679C");
+      const { passed, failed, skipped } = params.testResults;
+      if (passed !== void 0) {
+        lines.push(`- \u2705 \u6210\u529F: ${passed}`);
+      }
+      if (failed !== void 0) {
+        lines.push(`- \u274C \u5931\u6557: ${failed}`);
+      }
+      if (skipped !== void 0) {
+        lines.push(`- \u23ED\uFE0F \u30B9\u30AD\u30C3\u30D7: ${skipped}`);
+      }
+      lines.push("");
+    }
+    if (params.note) {
+      lines.push("### \u5099\u8003");
+      lines.push(params.note);
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push(`*\u{1F916} Generated by ${this.ai.charAt(0).toUpperCase() + this.ai.slice(1)} via Projects Plus SDK*`);
+    return lines.join("\n");
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://us-central1-projects-plus-app.cloudfunctions.net/api/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+var ProjectsPlus = class {
+  http;
+  /** Context resource for getting theme overview */
+  context;
+  /** Sessions resource for managing AI development sessions */
+  sessions;
+  /** Tasks resource for managing tasks */
+  tasks;
+  /** Projects resource for managing projects */
+  projects;
+  /** Comments resource for managing task comments */
+  comments;
+  /**
+   * Create a new Projects Plus client
+   *
+   * @param config - Client configuration
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.http = new HttpClient({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      retries: config.retries ?? DEFAULT_RETRIES,
+      retryDelay: config.retryDelay ?? DEFAULT_RETRY_DELAY
+    });
+    this.context = new ContextResource(this.http);
+    this.sessions = new SessionsResource(this.http);
+    this.tasks = new TasksResource(this.http);
+    this.projects = new ProjectsResource(this.http);
+    this.comments = new CommentsResource(this.http);
+  }
+  /**
+   * Create a workflow helper for common development patterns
+   *
+   * @param params - Workflow parameters
+   * @returns Workflow instance
+   *
+   * @example
+   * ```ts
+   * const workflow = pp.workflow({ ai: 'claude' });
+   *
+   * // Start session and get context in one call
+   * const { session, context } = await workflow.start();
+   *
+   * // Report progress with auto-formatted markdown
+   * await workflow.reportProgress('task-id', {
+   *   projectId: 'proj-id',
+   *   changes: ['file1.ts', 'file2.ts'],
+   *   testResults: { passed: 10, failed: 0 },
+   * });
+   *
+   * // Complete task and refresh context
+   * const newContext = await workflow.completeAndRefresh('task-id', {
+   *   projectId: 'proj-id'
+   * });
+   *
+   * // End session
+   * await workflow.end('Summary...');
+   * ```
+   */
+  workflow(params) {
+    return new Workflow(this, params.ai);
+  }
+};
+
+exports.ApiError = ApiError;
+exports.AuthenticationError = AuthenticationError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.ProjectsPlus = ProjectsPlus;
+exports.RateLimitError = RateLimitError;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.Workflow = Workflow;
+exports.createApiError = createApiError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map