@devpad/api 2.0.1 → 2.0.2

package/dist/index.js

@@ -1,6 +1,1345 @@
-import { ApiClient } from "./api-client";
-export { getUserFriendlyErrorMessage, parseZodErrors } from "./error-handlers";
-export { err, ok, wrap } from "./result";
-export { getTool, toolNames, tools } from "./tools";
-export { ApiClient };
-export default ApiClient;
+import {
+  ArrayBufferedQueue,
+  save_config_request,
+  save_tags_request,
+  upsert_goal,
+  upsert_milestone,
+  upsert_project,
+  upsert_todo
+} from "./chunk-WTGVONUB.js";
+import "./chunk-5X36WMYQ.js";
+import "./chunk-FOO5XXY5.js";
+
+// src/errors.ts
+var ApiError = class _ApiError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ApiError";
+    this.code = options.code ?? void 0;
+    this.statusCode = options.statusCode ?? void 0;
+  }
+  static fromResponse(response) {
+    return new _ApiError(`API request failed: ${response.statusText}`, {
+      statusCode: response.status
+    });
+  }
+};
+var AuthenticationError = class extends ApiError {
+  constructor(message = "Authentication failed") {
+    super(message, { code: "AUTHENTICATION_ERROR" });
+  }
+};
+var NetworkError = class extends ApiError {
+  constructor(message = "Network request failed") {
+    super(message, { code: "NETWORK_ERROR" });
+  }
+};
+var ValidationError = class extends ApiError {
+  constructor(message = "Validation failed") {
+    super(message, { code: "VALIDATION_ERROR" });
+  }
+};
+
+// src/error-handlers.ts
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  INTERNAL_SERVER_ERROR: 500
+};
+function handleHttpResponse(response) {
+  switch (response.status) {
+    case HTTP_STATUS.UNAUTHORIZED:
+      throw new AuthenticationError("Invalid or expired API key");
+    case HTTP_STATUS.NOT_FOUND:
+      throw new ApiError("Resource not found", { statusCode: HTTP_STATUS.NOT_FOUND });
+    case HTTP_STATUS.BAD_REQUEST:
+      break;
+    default:
+      if (!response.ok) {
+        throw new ApiError(`Request failed: ${response.statusText}`, { statusCode: response.status });
+      }
+  }
+}
+async function handleResponseError(response) {
+  const errorText = await response.text();
+  const errorMessage = errorText || "Request failed";
+  let parsedError = null;
+  try {
+    parsedError = JSON.parse(errorText);
+  } catch {
+  }
+  if (response.status === HTTP_STATUS.BAD_REQUEST && parsedError?.error?.name === "ZodError") {
+    const zodErrorDetails = parsedError.error?.issues ? JSON.stringify(parsedError.error) : errorMessage;
+    throw new ValidationError(zodErrorDetails);
+  }
+  throw new ApiError(errorMessage, { statusCode: response.status });
+}
+function handleNetworkError(error) {
+  const message = error instanceof Error ? error.message : "Unknown network error";
+  throw new NetworkError(message);
+}
+function isApiError(error) {
+  return error instanceof ApiError;
+}
+function isAuthenticationError(error) {
+  return error instanceof AuthenticationError;
+}
+function isNetworkError(error) {
+  return error instanceof NetworkError;
+}
+function parseZodErrors(errorMessage) {
+  try {
+    let parsedError = null;
+    try {
+      parsedError = JSON.parse(errorMessage);
+    } catch {
+      const zodErrorMatch = errorMessage.match(/ZodError: (.+)/);
+      if (zodErrorMatch && zodErrorMatch[1]) {
+        try {
+          parsedError = JSON.parse(zodErrorMatch[1]);
+        } catch {
+          const issuesMatch = errorMessage.match(/issues:\s*(\[.*\])/s);
+          if (issuesMatch && issuesMatch[1]) {
+            try {
+              parsedError = { issues: JSON.parse(issuesMatch[1]) };
+            } catch {
+            }
+          }
+        }
+      }
+    }
+    if (parsedError?.issues && Array.isArray(parsedError.issues)) {
+      const friendlyMessages = parsedError.issues.map((issue) => {
+        const path = issue.path && issue.path.length > 0 ? issue.path.join(".") : "field";
+        const message = issue.message || "is invalid";
+        switch (issue.code) {
+          case "invalid_type":
+            return `${path} must be a ${issue.expected} (received ${issue.received})`;
+          case "too_small":
+            if (issue.type === "string") {
+              return `${path} must be at least ${issue.minimum} characters long`;
+            }
+            if (issue.type === "number") {
+              return `${path} must be at least ${issue.minimum}`;
+            }
+            return `${path} is too small`;
+          case "too_big":
+            if (issue.type === "string") {
+              return `${path} must be no more than ${issue.maximum} characters long`;
+            }
+            if (issue.type === "number") {
+              return `${path} must be no more than ${issue.maximum}`;
+            }
+            return `${path} is too large`;
+          case "invalid_string":
+            if (issue.validation === "email") {
+              return `${path} must be a valid email address`;
+            }
+            if (issue.validation === "url") {
+              return `${path} must be a valid URL`;
+            }
+            if (issue.validation === "uuid") {
+              return `${path} must be a valid UUID`;
+            }
+            return `${path} format is invalid`;
+          case "custom":
+            return `${path}: ${message}`;
+          default:
+            return `${path}: ${message}`;
+        }
+      });
+      if (friendlyMessages.length === 1) {
+        return friendlyMessages[0];
+      }
+      return `Validation failed:
+\u2022 ${friendlyMessages.join("\n\u2022 ")}`;
+    }
+  } catch (e) {
+    console.debug("Failed to parse Zod error:", e);
+  }
+  return errorMessage;
+}
+function getUserFriendlyErrorMessage(error) {
+  if (isAuthenticationError(error)) {
+    return "Please check your API key and try again";
+  }
+  if (isNetworkError(error)) {
+    return "Network connection issue. Please try again";
+  }
+  if (isApiError(error)) {
+    if (error.statusCode === HTTP_STATUS.NOT_FOUND) {
+      return "The requested resource was not found";
+    }
+    if (error.statusCode === HTTP_STATUS.BAD_REQUEST) {
+      return "Invalid request. Please check your data";
+    }
+    if (error.code === "VALIDATION_ERROR" && error.message) {
+      return parseZodErrors(error.message);
+    }
+    return error.message || "An error occurred";
+  }
+  return "An unexpected error occurred";
+}
+
+// src/request.ts
+var ApiClient = class {
+  constructor(options) {
+    this.category = "api";
+    this.auth_mode = options.auth_mode ?? (options.api_key?.startsWith("jwt:") ? "session" : "key");
+    if (this.auth_mode !== "cookie") {
+      if (!options.api_key) throw new Error("API key is required");
+      if (options.api_key.length < 10) throw new Error("API key is too short");
+    }
+    this.base_url = options.base_url;
+    this.api_key = options.api_key ?? "";
+    this.category = options.category || "api";
+    this.credentials = options.credentials;
+    this.default_headers = options.default_headers ?? {};
+    this.custom_fetch = options.custom_fetch;
+    this.request_history = new ArrayBufferedQueue(options.max_history_size ?? 5);
+    this.debug = options.debug ?? false;
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.base_url}${path}`);
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value) url.searchParams.append(key, value);
+      });
+    }
+    return url.toString();
+  }
+  generateRequestId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", headers = {}, body, query } = options;
+    const url = this.buildUrl(path, query);
+    const requestId = this.generateRequestId();
+    const startTime = Date.now();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (this.debug) {
+      console.log(`[DEBUG][${this.category}] ${method} ${path} [${requestId}]`, { body, query });
+    }
+    const request_headers = {
+      "Content-Type": "application/json",
+      "X-Request-ID": requestId,
+      ...this.default_headers,
+      ...headers
+    };
+    if (this.auth_mode === "session") {
+      request_headers.Authorization = `Bearer jwt:${this.api_key.replace(/^jwt:/, "")}`;
+    } else if (this.auth_mode === "key") {
+      request_headers.Authorization = `Bearer ${this.api_key}`;
+    }
+    const historyEntry = {
+      timestamp,
+      method,
+      path,
+      options: { ...options, method },
+      url
+    };
+    try {
+      const fetchOptions = {
+        method,
+        headers: request_headers
+      };
+      if (body) {
+        fetchOptions.body = JSON.stringify(body);
+      }
+      if (this.credentials) {
+        fetchOptions.credentials = this.credentials;
+      } else if (this.auth_mode === "cookie") {
+        fetchOptions.credentials = "include";
+      }
+      const fetcher = this.custom_fetch ?? fetch;
+      const response = await fetcher(url, fetchOptions);
+      const duration = Date.now() - startTime;
+      historyEntry.status = response.status;
+      historyEntry.duration = duration;
+      if (!response.ok) {
+        if (this.debug) {
+          console.log(`[ERROR][${this.category}] ${method} ${path} [${requestId}] failed`, {
+            status: response.status,
+            duration: `${duration}ms`,
+            body,
+            query
+          });
+        }
+        try {
+          handleHttpResponse(response);
+          await handleResponseError(response);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Request failed";
+          historyEntry.error = errorMessage;
+          this.request_history.add(historyEntry);
+          throw error;
+        }
+      }
+      this.request_history.add(historyEntry);
+      let result;
+      if (response.status === HTTP_STATUS.NO_CONTENT) {
+        result = void 0;
+      } else {
+        const text = await response.text();
+        if (!text || text.trim() === "" || text.trim() === "null") {
+          result = void 0;
+        } else {
+          try {
+            result = JSON.parse(text);
+          } catch (parseError) {
+            result = text;
+          }
+        }
+      }
+      if (this.debug) {
+        console.log(`[INFO][${this.category}] ${method} ${path} [${requestId}] completed`, {
+          status: response.status,
+          duration: `${duration}ms`
+        });
+      }
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (this.debug) {
+        console.log(`[ERROR][${this.category}] ${method} ${path} [${requestId}] failed`, {
+          url,
+          duration: `${duration}ms`,
+          error: error instanceof Error ? error.message : String(error),
+          body,
+          query
+        });
+      }
+      if (error instanceof ApiError || error instanceof AuthenticationError) {
+        throw error;
+      }
+      historyEntry.duration = duration;
+      try {
+        handleNetworkError(error);
+      } catch (networkError) {
+        const errorMessage = networkError instanceof Error ? networkError.message : "Unknown network error";
+        historyEntry.error = errorMessage;
+        this.request_history.add(historyEntry);
+        throw networkError;
+      }
+    }
+  }
+  get(path, options = {}) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  post(path, options = {}) {
+    return this.request(path, { ...options, method: "POST" });
+  }
+  patch(path, options = {}) {
+    return this.request(path, { ...options, method: "PATCH" });
+  }
+  put(path, options = {}) {
+    return this.request(path, { ...options, method: "PUT" });
+  }
+  delete(path, options = {}) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+  history() {
+    return this.request_history;
+  }
+  url() {
+    return this.base_url;
+  }
+  headers() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.auth_mode === "session") {
+      headers.Authorization = `Bearer jwt:${this.api_key.replace(/^jwt:/, "")}`;
+    } else if (this.auth_mode === "key") {
+      headers["X-API-KEY"] = this.api_key;
+    }
+    return headers;
+  }
+};
+
+// src/result.ts
+import { err, ok } from "@f0rbit/corpus";
+function wrap(fn) {
+  return fn().then((data) => ok(data)).catch(
+    (error) => err({
+      message: error.message || "Unknown error",
+      code: error.code,
+      status_code: error.statusCode || error.status_code
+    })
+  );
+}
+
+// src/api-client.ts
+var ApiClient2 = class {
+  constructor(options) {
+    /**
+     * Auth namespace with Result-wrapped operations
+     */
+    this.auth = {
+      session: () => wrap(() => this.clients.auth_root.get("/auth/session")),
+      keys: {
+        list: () => wrap(() => this.clients.auth.get("/keys")),
+        create: (name) => wrap(() => this.clients.auth.post("/keys", { body: name ? { name } : {} })),
+        revoke: (key_id) => wrap(() => this.clients.auth.delete(`/keys/${key_id}`)),
+        remove: (key_id) => wrap(() => this.clients.auth.delete(`/keys/${key_id}`))
+      }
+    };
+    /**
+     * Projects namespace with Result-wrapped operations
+     */
+    this.projects = {
+      /**
+       * List projects with optional filtering
+       */
+      list: (filters) => wrap(() => this.clients.projects.get(filters?.private === false ? "/projects/public" : "/projects")),
+      /**
+       * Get project map
+       */
+      map: async (filters) => wrap(async () => {
+        const result = await this.projects.list(filters);
+        if (!result.ok) throw new Error(result.error.message);
+        return result.value.reduce(
+          (acc, project) => {
+            acc[project.id] = project;
+            return acc;
+          },
+          {}
+        );
+      }),
+      /**
+       * Get project by ID
+       */
+      find: (id) => wrap(() => this.clients.projects.get("/projects", { query: { id } })),
+      /**
+       * Get project by name
+       */
+      getByName: (name) => wrap(() => this.clients.projects.get("/projects", { query: { name } })),
+      /**
+       * Get project by ID (throws if not found)
+       */
+      getById: (id) => wrap(() => this.clients.projects.get("/projects", { query: { id } })),
+      /**
+       * Create a new project
+       */
+      create: (data) => wrap(() => this.clients.projects.patch("/projects", { body: data })),
+      /**
+       * Update an existing project
+       */
+      update: async (idOrData, changes) => wrap(async () => {
+        if (typeof idOrData === "object" && idOrData.id) {
+          return this.clients.projects.patch("/projects", { body: idOrData });
+        }
+        const id = idOrData;
+        if (!changes) {
+          throw new Error("Changes parameter required for update");
+        }
+        const result = await this.projects.find(id);
+        if (!result.ok) throw new Error(result.error.message);
+        if (!result.value) throw new Error(`Project with id ${id} not found`);
+        const project = result.value;
+        const updateData = {
+          id: project.id,
+          project_id: project.project_id,
+          owner_id: project.owner_id,
+          name: project.name,
+          description: project.description,
+          specification: project.specification,
+          repo_url: project.repo_url,
+          repo_id: project.repo_id,
+          icon_url: project.icon_url,
+          status: project.status,
+          deleted: project.deleted,
+          link_url: project.link_url,
+          link_text: project.link_text,
+          visibility: project.visibility,
+          current_version: project.current_version,
+          ...changes
+        };
+        return this.clients.projects.patch("/projects", { body: updateData });
+      }),
+      /**
+       * Project configuration operations
+       */
+      config: {
+        /**
+         * Get project configuration
+         */
+        load: (project_id) => wrap(() => this.clients.projects.get("/projects/config", { query: { project_id } })),
+        /**
+         * Save project configuration
+         */
+        save: (request) => wrap(() => this.clients.projects.patch("/projects/save_config", { body: request }))
+      },
+      /**
+       * Scanning operations
+       */
+      scan: {
+        /**
+         * Initiate a repository scan (returns stream)
+         */
+        initiate: async (project_id) => {
+          const response = await fetch(`${this.clients.projects.url()}/projects/scan?project_id=${project_id}`, {
+            method: "POST",
+            headers: this.clients.projects.headers()
+          });
+          if (!response.body) {
+            throw new Error("No response body");
+          }
+          const stream = response.body.pipeThrough(new TextDecoderStream());
+          return stream;
+        },
+        /**
+         * Get pending scan updates for a project
+         */
+        updates: (project_id) => wrap(() => this.clients.projects.get("/projects/updates", { query: { project_id } }).then((response) => response.updates)),
+        /**
+         * Process scan results
+         */
+        update: (project_id, data) => wrap(() => this.clients.projects.post("/projects/scan_status", { query: { project_id }, body: data }))
+      },
+      /**
+       * Get project history
+       */
+      history: (project_id) => wrap(() => this.clients.projects.get(`/projects/${project_id}/history`)),
+      /**
+       * Legacy methods (keeping for compatibility)
+       */
+      upsert: (data) => wrap(() => this.clients.projects.patch("/projects", { body: data })),
+      /**
+       * Fetch project specification from GitHub
+       */
+      specification: (project_id) => wrap(() => this.clients.projects.get("/projects/fetch_spec", { query: { project_id } })),
+      /**
+       * Delete project (soft delete)
+       */
+      deleteProject: (project) => wrap(() => this.clients.projects.patch("/projects", { body: { ...project, deleted: true } }))
+    };
+    /**
+     * Milestones namespace with Result-wrapped operations
+     */
+    this.milestones = {
+      /**
+       * List milestones for authenticated user
+       */
+      list: () => wrap(() => this.clients.milestones.get("/milestones")),
+      /**
+       * Get milestones by project ID
+       */
+      getByProject: (project_id) => wrap(() => this.clients.milestones.get(`/projects/${project_id}/milestones`)),
+      /**
+       * Get milestone by ID
+       */
+      find: (id) => wrap(async () => {
+        try {
+          return await this.clients.milestones.get(`/milestones/${id}`);
+        } catch (error) {
+          return null;
+        }
+      }),
+      /**
+       * Create new milestone
+       */
+      create: (data) => wrap(() => this.clients.milestones.post("/milestones", { body: data })),
+      /**
+       * Update milestone
+       */
+      update: async (id, data) => wrap(async () => {
+        const result = await this.milestones.find(id);
+        if (!result.ok) throw new Error(result.error.message);
+        if (!result.value) throw new Error(`Milestone with id ${id} not found`);
+        const milestone = result.value;
+        const updateData = {
+          id: milestone.id,
+          project_id: milestone.project_id,
+          name: data.name ?? milestone.name,
+          description: data.description ?? milestone.description,
+          target_time: data.target_time ?? milestone.target_time,
+          target_version: data.target_version ?? milestone.target_version
+        };
+        return this.clients.milestones.patch(`/milestones/${id}`, { body: updateData });
+      }),
+      /**
+       * Delete milestone (soft delete)
+       */
+      delete: (id) => wrap(() => this.clients.milestones.delete(`/milestones/${id}`)),
+      /**
+       * Get goals for a milestone
+       */
+      goals: (id) => wrap(() => this.clients.milestones.get(`/milestones/${id}/goals`))
+    };
+    /**
+     * Goals namespace with Result-wrapped operations
+     */
+    this.goals = {
+      /**
+       * List goals for authenticated user
+       */
+      list: () => wrap(() => this.clients.goals.get("/goals")),
+      /**
+       * Get goal by ID
+       */
+      find: (id) => wrap(() => this.clients.goals.get(`/goals/${id}`)),
+      /**
+       * Create new goal
+       */
+      create: (data) => wrap(() => this.clients.goals.post("/goals", { body: data })),
+      /**
+       * Update goal
+       */
+      update: async (id, data) => wrap(async () => {
+        const result = await this.goals.find(id);
+        if (!result.ok) throw new Error(result.error.message);
+        if (!result.value) throw new Error(`Goal with id ${id} not found`);
+        const goal = result.value;
+        const updateData = {
+          id: goal.id,
+          milestone_id: goal.milestone_id,
+          name: data.name ?? goal.name,
+          description: data.description ?? goal.description,
+          target_time: data.target_time ?? goal.target_time
+        };
+        return this.clients.goals.patch(`/goals/${id}`, { body: updateData });
+      }),
+      /**
+       * Delete goal (soft delete)
+       */
+      delete: (id) => wrap(() => this.clients.goals.delete(`/goals/${id}`))
+    };
+    /**
+     * Tasks namespace with Result-wrapped operations
+     */
+    this.tasks = {
+      /**
+       * List tasks with optional filtering
+       */
+      list: (filters) => wrap(() => {
+        const query = {};
+        if (filters?.project_id) query.project = filters.project_id;
+        if (filters?.tag_id) query.tag = filters.tag_id;
+        return this.clients.tasks.get("/tasks", Object.keys(query).length > 0 ? { query } : {});
+      }),
+      /**
+       * Get task by ID
+       */
+      find: (id) => wrap(() => this.clients.tasks.get("/tasks", { query: { id } })),
+      /**
+       * Get tasks by project ID
+       */
+      getByProject: (project_id) => wrap(() => this.clients.tasks.get(`/tasks`, { query: { project: project_id } })),
+      /**
+       * Create a new task
+       */
+      create: (data) => wrap(() => this.clients.tasks.patch("/tasks", { body: data })),
+      /**
+       * Update an existing task
+       */
+      update: async (id, changes) => wrap(async () => {
+        const result = await this.tasks.find(id);
+        if (!result.ok) throw new Error(result.error.message);
+        if (!result.value) throw new Error(`Task with id ${id} not found`);
+        const task = result.value;
+        const updateData = {
+          id,
+          title: task.task.title,
+          summary: task.task.summary,
+          description: task.task.description,
+          progress: task.task.progress,
+          visibility: task.task.visibility,
+          start_time: task.task.start_time,
+          end_time: task.task.end_time,
+          priority: task.task.priority,
+          owner_id: task.task.owner_id,
+          project_id: task.task.project_id,
+          ...changes
+        };
+        return this.clients.tasks.patch("/tasks", { body: updateData });
+      }),
+      /**
+       * Upsert task (create or update)
+       */
+      upsert: (data) => wrap(() => this.clients.tasks.patch("/tasks", { body: data })),
+      /**
+       * Save tags for tasks
+       */
+      saveTags: (data) => wrap(() => this.clients.tasks.patch("/tasks/save_tags", { body: data })),
+      /**
+       * Delete task (soft delete)
+       */
+      deleteTask: (task) => wrap(() => this.clients.tasks.patch("/tasks", { body: { ...task.task, deleted: true } })),
+      /**
+       * Task history operations
+       */
+      history: {
+        /**
+         * Get task history by task ID
+         */
+        get: (task_id) => wrap(() => this.clients.tasks.get(`/tasks/history/${task_id}`))
+      }
+    };
+    /**
+     * Tags namespace with Result-wrapped operations
+     */
+    this.tags = {
+      /**
+       * List tags for authenticated user
+       */
+      list: () => wrap(() => this.clients.tags.get("/tags"))
+    };
+    /**
+     * GitHub namespace with Result-wrapped operations
+     */
+    this.github = {
+      /**
+       * List repositories for authenticated user
+       */
+      repos: () => wrap(() => this.clients.github.get("/repos")),
+      /**
+       * List branches for a GitHub repository
+       */
+      branches: (owner, repo) => wrap(() => this.clients.github.get(`/repos/${owner}/${repo}/branches`))
+    };
+    this.blog = {
+      posts: {
+        list: (params) => wrap(() => {
+          const query = {};
+          if (params?.category) query.category = params.category;
+          if (params?.tag) query.tag = params.tag;
+          if (params?.project) query.project = params.project;
+          if (params?.status) query.status = params.status;
+          if (params?.archived !== void 0) query.archived = String(params.archived);
+          if (params?.limit) query.limit = String(params.limit);
+          if (params?.offset !== void 0) query.offset = String(params.offset);
+          if (params?.sort) query.sort = params.sort;
+          return this.clients.blog.get("/blog/posts", Object.keys(query).length ? { query } : {});
+        }),
+        getBySlug: (slug) => wrap(() => this.clients.blog.get(`/blog/posts/${slug}`)),
+        create: (data) => wrap(() => this.clients.blog.post("/blog/posts", { body: data })),
+        update: (uuid, data) => wrap(() => this.clients.blog.put(`/blog/posts/${uuid}`, { body: data })),
+        delete: (uuid) => wrap(() => this.clients.blog.delete(`/blog/posts/${uuid}`)),
+        versions: (uuid) => wrap(() => this.clients.blog.get(`/blog/posts/${uuid}/versions`)),
+        version: (uuid, hash) => wrap(() => this.clients.blog.get(`/blog/posts/${uuid}/version/${hash}`)),
+        restore: (uuid, hash) => wrap(() => this.clients.blog.post(`/blog/posts/${uuid}/restore/${hash}`))
+      },
+      tags: {
+        list: () => wrap(() => this.clients.blog.get("/blog/tags")),
+        getForPost: (uuid) => wrap(() => this.clients.blog.get(`/blog/tags/posts/${uuid}/tags`)),
+        setForPost: (uuid, tags) => wrap(() => this.clients.blog.put(`/blog/tags/posts/${uuid}/tags`, { body: { tags } })),
+        addToPost: (uuid, tags) => wrap(() => this.clients.blog.post(`/blog/tags/posts/${uuid}/tags`, { body: { tags } })),
+        removeFromPost: (uuid, tag) => wrap(() => this.clients.blog.delete(`/blog/tags/posts/${uuid}/tags/${tag}`))
+      },
+      categories: {
+        tree: () => wrap(() => this.clients.blog.get("/blog/categories")),
+        create: (data) => wrap(() => this.clients.blog.post("/blog/categories", { body: data })),
+        update: (name, data) => wrap(() => this.clients.blog.put(`/blog/categories/${name}`, { body: data })),
+        delete: (name) => wrap(() => this.clients.blog.delete(`/blog/categories/${name}`))
+      },
+      tokens: {
+        list: () => wrap(() => this.clients.blog.get("/blog/tokens")),
+        create: (data) => wrap(() => this.clients.blog.post("/blog/tokens", { body: data })),
+        update: (id, data) => wrap(() => this.clients.blog.put(`/blog/tokens/${id}`, { body: data })),
+        delete: (id) => wrap(() => this.clients.blog.delete(`/blog/tokens/${id}`))
+      }
+    };
+    this.media = {
+      profiles: {
+        list: () => wrap(async () => {
+          const res = await this.clients.media.get("/profiles");
+          return res.profiles;
+        }),
+        create: (data) => wrap(() => this.clients.media.post("/profiles", { body: data })),
+        get: (id) => wrap(() => this.clients.media.get(`/profiles/${id}`)),
+        update: (id, data) => wrap(() => this.clients.media.patch(`/profiles/${id}`, { body: data })),
+        delete: (id) => wrap(() => this.clients.media.delete(`/profiles/${id}`)),
+        filters: {
+          list: (profile_id) => wrap(async () => {
+            const res = await this.clients.media.get(`/profiles/${profile_id}/filters`);
+            return res.filters;
+          }),
+          add: (profile_id, data) => wrap(() => this.clients.media.post(`/profiles/${profile_id}/filters`, { body: data })),
+          remove: (profile_id, filter_id) => wrap(() => this.clients.media.delete(`/profiles/${profile_id}/filters/${filter_id}`))
+        },
+        timeline: (slug, params) => wrap(() => {
+          const query = {};
+          if (params?.limit) query.limit = String(params.limit);
+          if (params?.before) query.before = params.before;
+          return this.clients.media.get(`/profiles/${slug}/timeline`, Object.keys(query).length ? { query } : {});
+        })
+      },
+      connections: {
+        list: (profile_id, options) => wrap(async () => {
+          const query = { profile_id };
+          if (options?.include_settings) query.include_settings = "true";
+          const res = await this.clients.media.get("/connections", { query });
+          return res.accounts;
+        }),
+        create: (data) => wrap(() => this.clients.media.post("/connections", { body: data })),
+        delete: (account_id) => wrap(() => this.clients.media.delete(`/connections/${account_id}`)),
+        refresh: (account_id) => wrap(() => this.clients.media.post(`/connections/${account_id}/refresh`)),
+        refreshAll: () => wrap(() => this.clients.media.post("/connections/refresh-all")),
+        updateStatus: (account_id, is_active) => wrap(() => this.clients.media.patch(`/connections/${account_id}`, { body: { is_active } })),
+        settings: {
+          get: (account_id) => wrap(() => this.clients.media.get(`/connections/${account_id}/settings`)),
+          update: (account_id, settings) => wrap(() => this.clients.media.put(`/connections/${account_id}/settings`, { body: { settings } }))
+        },
+        repos: (account_id) => wrap(async () => {
+          const res = await this.clients.media.get(`/connections/${account_id}/repos`);
+          return res.repos;
+        }),
+        subreddits: (account_id) => wrap(async () => {
+          const res = await this.clients.media.get(`/connections/${account_id}/subreddits`);
+          return res.subreddits;
+        })
+      },
+      credentials: {
+        check: (platform, profile_id) => wrap(() => this.clients.media.get(`/credentials/${platform}`, { query: { profile_id } })),
+        save: (platform, data) => wrap(() => this.clients.media.post(`/credentials/${platform}`, { body: data })),
+        delete: (platform, profile_id) => wrap(() => this.clients.media.delete(`/credentials/${platform}`, { query: { profile_id } }))
+      },
+      timeline: {
+        get: (user_id, params) => wrap(() => {
+          const query = {};
+          if (params?.from) query.from = params.from;
+          if (params?.to) query.to = params.to;
+          return this.clients.media.get(`/timeline/${user_id}`, Object.keys(query).length ? { query } : {});
+        }),
+        getRaw: (user_id, platform, account_id) => wrap(() => this.clients.media.get(`/timeline/${user_id}/raw/${platform}`, { query: { account_id } }))
+      }
+    };
+    /**
+     * User namespace with Result-wrapped operations
+     */
+    this.user = {
+      /**
+       * Get user activity history
+       */
+      history: () => wrap(() => this.clients.auth.get("/user/history")),
+      /**
+       * Update user preferences
+       */
+      preferences: (data) => wrap(() => this.clients.auth.patch("/user/preferences", { body: data }))
+    };
+    const base_url = options.base_url || "http://localhost:4321/api/v1";
+    this._api_key = options.api_key ?? "";
+    this._auth_mode = options.auth_mode ?? (options.api_key?.startsWith("jwt:") ? "session" : options.api_key ? "key" : "cookie");
+    const clientOptions = {
+      base_url,
+      api_key: options.api_key,
+      max_history_size: options.max_history_size,
+      auth_mode: this._auth_mode,
+      credentials: options.credentials,
+      default_headers: options.default_headers,
+      custom_fetch: options.custom_fetch
+    };
+    const auth_base_url = base_url.replace(/\/v1\/?$/, "");
+    this.clients = {
+      auth: new ApiClient({ ...clientOptions, category: "auth" }),
+      auth_root: new ApiClient({ ...clientOptions, base_url: auth_base_url, category: "auth" }),
+      projects: new ApiClient({ ...clientOptions, category: "projects" }),
+      tasks: new ApiClient({ ...clientOptions, category: "tasks" }),
+      milestones: new ApiClient({ ...clientOptions, category: "milestones" }),
+      goals: new ApiClient({ ...clientOptions, category: "goals" }),
+      github: new ApiClient({ ...clientOptions, category: "github" }),
+      tags: new ApiClient({ ...clientOptions, category: "tags" }),
+      blog: new ApiClient({ ...clientOptions, category: "blog" }),
+      media: new ApiClient({ ...clientOptions, category: "media" })
+    };
+  }
+  /**
+   * Get request history for debugging
+   */
+  history() {
+    return this.clients.projects.history();
+  }
+  /**
+   * Get the API key
+   */
+  getApiKey() {
+    return this._api_key;
+  }
+  /**
+   * Get the authentication mode
+   */
+  getAuthMode() {
+    return this._auth_mode;
+  }
+};
+
+// src/tools.ts
+import { z } from "zod";
+function unwrap(result) {
+  if (!result.ok) throw new Error(result.error?.message ?? "Unknown error");
+  return result.value;
+}
+var project_filters = z.object({
+  private: z.boolean().optional().describe("Include private projects (default: true)")
+});
+var project_by_id_or_name = z.object({
+  id: z.string().optional().describe("Project ID"),
+  name: z.string().optional().describe("Project name")
+}).refine((data) => data.id || data.name, {
+  message: "Either 'id' or 'name' must be provided"
+});
+var task_filters = z.object({
+  project_id: z.string().optional().describe("Filter by project ID"),
+  tag_id: z.string().optional().describe("Filter by tag ID")
+});
+var task_by_id = z.object({
+  id: z.string().describe("Task ID")
+});
+var milestone_filters = z.object({
+  project_id: z.string().optional().describe("Filter by project ID")
+});
+var milestone_by_id = z.object({
+  id: z.string().describe("Milestone ID")
+});
+var goal_by_id = z.object({
+  id: z.string().describe("Goal ID")
+});
+var github_branches = z.object({
+  owner: z.string().describe("Repository owner"),
+  repo: z.string().describe("Repository name")
+});
+var tools = {
+  // Projects
+  devpad_projects_list: {
+    name: "devpad_projects_list",
+    description: "List all projects (or only public ones)",
+    inputSchema: project_filters,
+    execute: async (client, input) => unwrap(await client.projects.list(input))
+  },
+  devpad_projects_get: {
+    name: "devpad_projects_get",
+    description: "Get project by ID or name",
+    inputSchema: project_by_id_or_name,
+    execute: async (client, input) => unwrap(input.id ? await client.projects.getById(input.id) : await client.projects.getByName(input.name))
+  },
+  devpad_projects_upsert: {
+    name: "devpad_projects_upsert",
+    description: "Create or update a project (set deleted=true to delete)",
+    inputSchema: upsert_project,
+    execute: async (client, input) => unwrap(await client.projects.upsert(input))
+  },
+  devpad_projects_config_save: {
+    name: "devpad_projects_config_save",
+    description: "Save project configuration",
+    inputSchema: save_config_request,
+    execute: async (client, input) => {
+      unwrap(await client.projects.config.save(input));
+      return { success: true };
+    }
+  },
+  // Tasks
+  devpad_tasks_list: {
+    name: "devpad_tasks_list",
+    description: "List tasks, optionally filtered by project or tag",
+    inputSchema: task_filters,
+    execute: async (client, input) => unwrap(await client.tasks.list(input))
+  },
+  devpad_tasks_get: {
+    name: "devpad_tasks_get",
+    description: "Get task by ID",
+    inputSchema: task_by_id,
+    execute: async (client, input) => unwrap(await client.tasks.find(input.id))
+  },
+  devpad_tasks_upsert: {
+    name: "devpad_tasks_upsert",
+    description: "Create or update a task (set deleted=true to delete)",
+    inputSchema: upsert_todo,
+    execute: async (client, input) => unwrap(await client.tasks.upsert(input))
+  },
+  devpad_tasks_save_tags: {
+    name: "devpad_tasks_save_tags",
+    description: "Save tags for tasks",
+    inputSchema: save_tags_request,
+    execute: async (client, input) => {
+      unwrap(await client.tasks.saveTags(input));
+      return { success: true };
+    }
+  },
+  // Milestones
+  devpad_milestones_list: {
+    name: "devpad_milestones_list",
+    description: "List milestones for authenticated user or by project",
+    inputSchema: milestone_filters,
+    execute: async (client, input) => unwrap(input.project_id ? await client.milestones.getByProject(input.project_id) : await client.milestones.list())
+  },
+  devpad_milestones_get: {
+    name: "devpad_milestones_get",
+    description: "Get milestone by ID",
+    inputSchema: milestone_by_id,
+    execute: async (client, input) => unwrap(await client.milestones.find(input.id))
+  },
+  devpad_milestones_upsert: {
+    name: "devpad_milestones_upsert",
+    description: "Create or update a milestone",
+    inputSchema: upsert_milestone,
+    execute: async (client, input) => unwrap(
+      input.id ? await client.milestones.update(input.id, {
+        name: input.name,
+        description: input.description,
+        target_time: input.target_time,
+        target_version: input.target_version
+      }) : await client.milestones.create({
+        project_id: input.project_id,
+        name: input.name,
+        description: input.description,
+        target_time: input.target_time,
+        target_version: input.target_version
+      })
+    )
+  },
+  // Goals
+  devpad_goals_list: {
+    name: "devpad_goals_list",
+    description: "List goals for authenticated user",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.goals.list())
+  },
+  devpad_goals_get: {
+    name: "devpad_goals_get",
+    description: "Get goal by ID",
+    inputSchema: goal_by_id,
+    execute: async (client, input) => unwrap(await client.goals.find(input.id))
+  },
+  devpad_goals_upsert: {
+    name: "devpad_goals_upsert",
+    description: "Create or update a goal",
+    inputSchema: upsert_goal,
+    execute: async (client, input) => unwrap(
+      input.id ? await client.goals.update(input.id, {
+        name: input.name,
+        description: input.description,
+        target_time: input.target_time
+      }) : await client.goals.create({
+        milestone_id: input.milestone_id,
+        name: input.name,
+        description: input.description,
+        target_time: input.target_time
+      })
+    )
+  },
+  // Tags
+  devpad_tags_list: {
+    name: "devpad_tags_list",
+    description: "List tags for authenticated user",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.tags.list())
+  },
+  // GitHub integration
+  devpad_github_repos: {
+    name: "devpad_github_repos",
+    description: "List GitHub repositories for authenticated user",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.github.repos())
+  },
+  devpad_github_branches: {
+    name: "devpad_github_branches",
+    description: "List branches for a GitHub repository",
+    inputSchema: github_branches,
+    execute: async (client, input) => unwrap(await client.github.branches(input.owner, input.repo))
+  },
+  // Additional project operations
+  devpad_projects_delete: {
+    name: "devpad_projects_delete",
+    description: "Delete a project",
+    inputSchema: z.object({
+      id: z.string().describe("Project ID")
+    }),
+    execute: async (client, input) => {
+      const project = unwrap(await client.projects.find(input.id));
+      if (!project) throw new Error(`Project ${input.id} not found`);
+      unwrap(await client.projects.deleteProject(project));
+      return { success: true };
+    }
+  },
+  devpad_projects_history: {
+    name: "devpad_projects_history",
+    description: "Get project history",
+    inputSchema: z.object({
+      project_id: z.string().describe("Project ID")
+    }),
+    execute: async (client, input) => unwrap(await client.projects.history(input.project_id))
+  },
+  devpad_projects_specification: {
+    name: "devpad_projects_specification",
+    description: "Fetch project specification from GitHub",
+    inputSchema: z.object({
+      project_id: z.string().describe("Project ID")
+    }),
+    execute: async (client, input) => unwrap(await client.projects.specification(input.project_id))
+  },
+  devpad_projects_config_load: {
+    name: "devpad_projects_config_load",
+    description: "Load project configuration",
+    inputSchema: z.object({
+      project_id: z.string().describe("Project ID")
+    }),
+    execute: async (client, input) => unwrap(await client.projects.config.load(input.project_id))
+  },
+  // Additional milestone operations
+  devpad_milestones_delete: {
+    name: "devpad_milestones_delete",
+    description: "Delete a milestone",
+    inputSchema: z.object({
+      id: z.string().describe("Milestone ID")
+    }),
+    execute: async (client, input) => unwrap(await client.milestones.delete(input.id))
+  },
+  devpad_milestones_goals: {
+    name: "devpad_milestones_goals",
+    description: "Get goals for a milestone",
+    inputSchema: z.object({
+      id: z.string().describe("Milestone ID")
+    }),
+    execute: async (client, input) => unwrap(await client.milestones.goals(input.id))
+  },
+  // Additional goal operations
+  devpad_goals_delete: {
+    name: "devpad_goals_delete",
+    description: "Delete a goal",
+    inputSchema: z.object({
+      id: z.string().describe("Goal ID")
+    }),
+    execute: async (client, input) => unwrap(await client.goals.delete(input.id))
+  },
+  // Additional task operations
+  devpad_tasks_delete: {
+    name: "devpad_tasks_delete",
+    description: "Delete a task",
+    inputSchema: z.object({
+      id: z.string().describe("Task ID")
+    }),
+    execute: async (client, input) => {
+      const task = unwrap(await client.tasks.find(input.id));
+      if (!task) throw new Error(`Task ${input.id} not found`);
+      unwrap(await client.tasks.deleteTask(task));
+      return { success: true };
+    }
+  },
+  devpad_tasks_history: {
+    name: "devpad_tasks_history",
+    description: "Get task history",
+    inputSchema: z.object({
+      task_id: z.string().describe("Task ID")
+    }),
+    execute: async (client, input) => unwrap(await client.tasks.history.get(input.task_id))
+  },
+  // User operations
+  devpad_user_history: {
+    name: "devpad_user_history",
+    description: "Get user activity history",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.user.history())
+  },
+  devpad_user_preferences: {
+    name: "devpad_user_preferences",
+    description: "Update user preferences",
+    inputSchema: z.object({
+      id: z.string().describe("User ID"),
+      task_view: z.enum(["list", "grid"]).describe("Task view preference")
+    }),
+    execute: async (client, input) => unwrap(await client.user.preferences(input))
+  },
+  devpad_blog_posts_list: {
+    name: "devpad_blog_posts_list",
+    description: "List blog posts with optional filters",
+    inputSchema: z.object({
+      category: z.string().optional().describe("Filter by category"),
+      tag: z.string().optional().describe("Filter by tag"),
+      project: z.string().optional().describe("Filter by project ID"),
+      status: z.enum(["draft", "published"]).optional().describe("Filter by status"),
+      archived: z.boolean().optional().describe("Filter by archived state"),
+      limit: z.number().optional().describe("Max posts to return"),
+      offset: z.number().optional().describe("Offset for pagination"),
+      sort: z.string().optional().describe("Sort order")
+    }),
+    execute: async (client, input) => unwrap(await client.blog.posts.list(input))
+  },
+  devpad_blog_posts_get: {
+    name: "devpad_blog_posts_get",
+    description: "Get a blog post by slug",
+    inputSchema: z.object({
+      slug: z.string().describe("Post slug")
+    }),
+    execute: async (client, input) => unwrap(await client.blog.posts.getBySlug(input.slug))
+  },
+  devpad_blog_posts_create: {
+    name: "devpad_blog_posts_create",
+    description: "Create a new blog post",
+    inputSchema: z.object({
+      title: z.string().describe("Post title"),
+      content: z.string().describe("Post content"),
+      format: z.enum(["markdown", "html"]).describe("Content format"),
+      slug: z.string().optional().describe("Custom slug"),
+      category: z.string().optional().describe("Category name"),
+      tags: z.array(z.string()).optional().describe("Tag names"),
+      description: z.string().optional().describe("Post description"),
+      publish_at: z.string().optional().describe("Scheduled publish date (ISO string)"),
+      project_ids: z.array(z.string()).optional().describe("Associated project IDs"),
+      archived: z.boolean().optional().describe("Whether post is archived")
+    }),
+    execute: async (client, input) => unwrap(await client.blog.posts.create(input))
+  },
+  devpad_blog_posts_update: {
+    name: "devpad_blog_posts_update",
+    description: "Update a blog post by UUID",
+    inputSchema: z.object({
+      uuid: z.string().describe("Post UUID"),
+      title: z.string().optional().describe("Post title"),
+      content: z.string().optional().describe("Post content"),
+      format: z.enum(["markdown", "html"]).optional().describe("Content format"),
+      slug: z.string().optional().describe("Custom slug"),
+      category: z.string().optional().describe("Category name"),
+      tags: z.array(z.string()).optional().describe("Tag names"),
+      description: z.string().optional().describe("Post description"),
+      publish_at: z.string().optional().describe("Scheduled publish date (ISO string)"),
+      project_ids: z.array(z.string()).optional().describe("Associated project IDs"),
+      archived: z.boolean().optional().describe("Whether post is archived")
+    }),
+    execute: async (client, input) => {
+      const { uuid, ...data } = input;
+      return unwrap(await client.blog.posts.update(uuid, data));
+    }
+  },
+  devpad_blog_posts_delete: {
+    name: "devpad_blog_posts_delete",
+    description: "Delete a blog post by UUID",
+    inputSchema: z.object({
+      uuid: z.string().describe("Post UUID")
+    }),
+    execute: async (client, input) => unwrap(await client.blog.posts.delete(input.uuid))
+  },
+  devpad_blog_tags_list: {
+    name: "devpad_blog_tags_list",
+    description: "List all blog tags with post counts",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.blog.tags.list())
+  },
+  devpad_blog_categories_tree: {
+    name: "devpad_blog_categories_tree",
+    description: "Get the blog category tree",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.blog.categories.tree())
+  },
+  devpad_blog_categories_create: {
+    name: "devpad_blog_categories_create",
+    description: "Create a blog category",
+    inputSchema: z.object({
+      name: z.string().describe("Category name"),
+      parent: z.string().optional().describe("Parent category name")
+    }),
+    execute: async (client, input) => unwrap(await client.blog.categories.create(input))
+  },
+  devpad_blog_tokens_list: {
+    name: "devpad_blog_tokens_list",
+    description: "List blog access tokens",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.blog.tokens.list())
+  },
+  devpad_blog_tokens_create: {
+    name: "devpad_blog_tokens_create",
+    description: "Create a blog access token",
+    inputSchema: z.object({
+      name: z.string().describe("Token name"),
+      note: z.string().optional().describe("Optional note")
+    }),
+    execute: async (client, input) => unwrap(await client.blog.tokens.create(input))
+  },
+  devpad_media_profiles_list: {
+    name: "devpad_media_profiles_list",
+    description: "List media profiles",
+    inputSchema: z.object({}),
+    execute: async (client) => unwrap(await client.media.profiles.list())
+  },
+  devpad_media_profiles_create: {
+    name: "devpad_media_profiles_create",
+    description: "Create a media profile",
+    inputSchema: z.object({
+      name: z.string().describe("Profile name"),
+      slug: z.string().describe("Profile slug")
+    }),
+    execute: async (client, input) => unwrap(await client.media.profiles.create(input))
+  },
+  devpad_media_profiles_get: {
+    name: "devpad_media_profiles_get",
+    description: "Get a media profile by ID",
+    inputSchema: z.object({
+      id: z.string().describe("Profile ID")
+    }),
+    execute: async (client, input) => unwrap(await client.media.profiles.get(input.id))
+  },
+  devpad_media_profiles_update: {
+    name: "devpad_media_profiles_update",
+    description: "Update a media profile by ID",
+    inputSchema: z.object({
+      id: z.string().describe("Profile ID"),
+      name: z.string().optional().describe("Profile name"),
+      slug: z.string().optional().describe("Profile slug")
+    }),
+    execute: async (client, input) => {
+      const { id, ...data } = input;
+      return unwrap(await client.media.profiles.update(id, data));
+    }
+  },
+  devpad_media_profiles_delete: {
+    name: "devpad_media_profiles_delete",
+    description: "Delete a media profile by ID",
+    inputSchema: z.object({
+      id: z.string().describe("Profile ID")
+    }),
+    execute: async (client, input) => unwrap(await client.media.profiles.delete(input.id))
+  },
+  devpad_media_connections_list: {
+    name: "devpad_media_connections_list",
+    description: "List connections for a media profile",
+    inputSchema: z.object({
+      profile_id: z.string().describe("Profile ID")
+    }),
+    execute: async (client, input) => unwrap(await client.media.connections.list(input.profile_id))
+  },
+  devpad_media_connections_refresh: {
+    name: "devpad_media_connections_refresh",
+    description: "Refresh a media connection",
+    inputSchema: z.object({
+      account_id: z.string().describe("Account/connection ID")
+    }),
+    execute: async (client, input) => unwrap(await client.media.connections.refresh(input.account_id))
+  },
+  devpad_media_timeline_get: {
+    name: "devpad_media_timeline_get",
+    description: "Get media timeline for a user",
+    inputSchema: z.object({
+      user_id: z.string().describe("User ID"),
+      from: z.string().optional().describe("Start date (ISO string)"),
+      to: z.string().optional().describe("End date (ISO string)")
+    }),
+    execute: async (client, input) => {
+      const { user_id, ...params } = input;
+      return unwrap(await client.media.timeline.get(user_id, params));
+    }
+  }
+};
+var toolNames = Object.keys(tools);
+function getTool(name) {
+  return tools[name];
+}
+
+// src/index.ts
+var src_default = ApiClient2;
+export {
+  ApiClient2 as ApiClient,
+  src_default as default,
+  err,
+  getTool,
+  getUserFriendlyErrorMessage,
+  ok,
+  parseZodErrors,
+  toolNames,
+  tools,
+  wrap
+};