@fixerorg/schemas 1.0.0

package/dist/index.js

@@ -0,0 +1,435 @@
+// src/routes.ts
+var API_BASE = "/api";
+var API_ROUTES = {
+  settings: "/api/settings",
+  projects: "/api/projects",
+  tasks: "/api/tasks",
+  github: "/api/github",
+  worktree: "/api/worktree",
+  issueTemplates: "/api/issue-templates",
+  health: "/api/health"
+};
+var SETTINGS = {
+  /** 获取/更新设置 */
+  base: `${API_BASE}/settings`,
+  /** GitHub Token 验证 */
+  verifyGithub: `${API_BASE}/settings/github/verify`
+};
+var PROJECTS = {
+  /** 项目列表 */
+  list: `${API_BASE}/projects`,
+  /** 单个项目 */
+  detail: (projectId) => `${API_BASE}/projects/${projectId}`,
+  /** 同步项目 */
+  sync: (projectId) => `${API_BASE}/projects/${projectId}/sync`
+};
+var ISSUES = {
+  /** 项目下的 Issue 列表 */
+  listByProject: (projectId) => `${API_BASE}/projects/${projectId}/issues`,
+  /** 创建 Issue */
+  create: (projectId) => `${API_BASE}/projects/${projectId}/issues`,
+  /** 单个 Issue */
+  detail: (projectId, issueId) => `${API_BASE}/projects/${projectId}/issues/${issueId}`,
+  /** 更新 Issue */
+  update: (projectId, issueId) => `${API_BASE}/projects/${projectId}/issues/${issueId}`,
+  /** 删除 Issue */
+  delete: (projectId, issueId) => `${API_BASE}/projects/${projectId}/issues/${issueId}`,
+  /** AI 聊天 */
+  aiChat: (projectId, issueId) => `${API_BASE}/projects/${projectId}/issues/${issueId}/ai/chat`
+};
+var TASKS = {
+  /** Issue 下的 Task 列表 */
+  listByIssue: (issueId) => `${API_BASE}/tasks/issue/${issueId}`,
+  /** 创建 Task */
+  create: (issueId) => `${API_BASE}/tasks/issue/${issueId}`,
+  /** 单个 Task */
+  detail: (taskId) => `${API_BASE}/tasks/${taskId}`,
+  /** 更新 Task */
+  update: (taskId) => `${API_BASE}/tasks/${taskId}`,
+  /** 取消 Task */
+  cancel: (taskId) => `${API_BASE}/tasks/${taskId}/cancel`,
+  /** 删除 Task */
+  delete: (taskId) => `${API_BASE}/tasks/${taskId}`
+};
+var GITHUB = {
+  /** 获取仓库列表 */
+  repos: `${API_BASE}/github/repos`,
+  /** 获取仓库分支 */
+  branches: (owner, repo) => `${API_BASE}/github/repos/${owner}/${repo}/branches`
+};
+var WORKTREE = {
+  /** 获取 Worktree 状态 */
+  status: (issueId) => `${API_BASE}/worktree/issue/${issueId}`,
+  /** 创建 Worktree */
+  create: (issueId) => `${API_BASE}/worktree/issue/${issueId}`,
+  /** 删除 Worktree */
+  delete: (issueId) => `${API_BASE}/worktree/issue/${issueId}`
+};
+var ISSUE_TEMPLATES = {
+  /** 模板列表（全局） */
+  list: `${API_BASE}/issue-templates`,
+  /** 获取项目下的模板列表 */
+  byProject: (projectId) => `${API_BASE}/issue-templates/project/${projectId}`,
+  /** 获取单个模板 */
+  detail: (projectId, name) => `${API_BASE}/issue-templates/project/${projectId}/${name}`
+};
+var AI = {
+  /** AI 聊天 (SSE) - 实际端点由 ISSUES.aiChat 提供 */
+  chat: (projectId, issueId) => ISSUES.aiChat(projectId, issueId)
+};
+var HEALTH = `${API_BASE}/health`;
+
+// src/common.ts
+import { z } from "zod";
+var SyncStatusSchema = z.enum(["syncing", "synced", "error"]);
+var IssueStatusSchema = z.enum(["open", "in_progress", "in_review", "done"]);
+var IssuePrioritySchema = z.enum(["high", "medium", "low"]);
+var TaskStatusSchema = z.enum(["pending", "active", "completed", "cancelled", "error"]);
+var WorktreeStatusSchema = z.enum(["pending", "creating", "ready", "error"]);
+var PaginatedResponseSchema = (itemSchema) => z.object({
+  items: z.array(itemSchema),
+  total: z.number().int().nonnegative(),
+  page: z.number().int().positive(),
+  per_page: z.number().int().positive(),
+  pages: z.number().int().nonnegative()
+});
+var PaginationQuerySchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  per_page: z.coerce.number().int().positive().max(100).default(20)
+});
+
+// src/project.ts
+import { z as z2 } from "zod";
+var IssueStatsSchema = z2.object({
+  total: z2.number().int().nonnegative(),
+  done: z2.number().int().nonnegative()
+});
+var ProjectResponseSchema = z2.object({
+  id: z2.number().int(),
+  projectId: z2.string(),
+  name: z2.string(),
+  description: z2.string().nullable(),
+  color: z2.string(),
+  githubRepoId: z2.number().int().nullable(),
+  defaultBranch: z2.string(),
+  selectedBranch: z2.string(),
+  cloneUrl: z2.string().nullable(),
+  starsCount: z2.number().int().nonnegative(),
+  forksCount: z2.number().int().nonnegative(),
+  syncStatus: SyncStatusSchema,
+  localPath: z2.string().nullable(),
+  lastSyncAt: z2.coerce.date().nullable(),
+  lastActivity: z2.string().nullable(),
+  syncError: z2.string().nullable(),
+  createdAt: z2.coerce.date(),
+  updatedAt: z2.coerce.date(),
+  issueStats: IssueStatsSchema.optional()
+});
+var ProjectCreateSchema = z2.object({
+  repo: z2.string().min(1),
+  branch: z2.string().default("main")
+});
+var ProjectUpdateSchema = z2.object({
+  selectedBranch: z2.string().optional(),
+  color: z2.string().optional()
+});
+var ProjectListResponseSchema = PaginatedResponseSchema(ProjectResponseSchema);
+
+// src/task.ts
+import { z as z3 } from "zod";
+var TaskResponseSchema = z3.object({
+  id: z3.number().int(),
+  issueId: z3.string(),
+  name: z3.string(),
+  status: TaskStatusSchema,
+  output: z3.unknown().nullable(),
+  startedAt: z3.coerce.date().nullable(),
+  completedAt: z3.coerce.date().nullable(),
+  createdAt: z3.coerce.date(),
+  updatedAt: z3.coerce.date()
+});
+var TaskCreateSchema = z3.object({
+  name: z3.string().min(1),
+  issueId: z3.string().min(1)
+});
+var TaskUpdateSchema = z3.object({
+  status: TaskStatusSchema.optional(),
+  output: z3.unknown().optional()
+});
+var TaskListResponseSchema = PaginatedResponseSchema(TaskResponseSchema);
+
+// src/issue.ts
+import { z as z4 } from "zod";
+var IssueResponseSchema = z4.object({
+  id: z4.number().int(),
+  issueId: z4.string(),
+  projectId: z4.string(),
+  title: z4.string(),
+  description: z4.string().nullable(),
+  status: IssueStatusSchema,
+  priority: IssuePrioritySchema,
+  tags: z4.array(z4.string()),
+  branchName: z4.string().nullable(),
+  worktreePath: z4.string().nullable(),
+  worktreeStatus: WorktreeStatusSchema,
+  worktreeError: z4.string().nullable(),
+  worktreeCreatedAt: z4.coerce.date().nullable(),
+  createdAt: z4.coerce.date(),
+  updatedAt: z4.coerce.date()
+});
+var IssueCreateSchema = z4.object({
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  priority: IssuePrioritySchema.optional(),
+  tags: z4.array(z4.string()).optional()
+});
+var IssueUpdateSchema = z4.object({
+  title: z4.string().min(1).optional(),
+  description: z4.string().optional(),
+  status: IssueStatusSchema.optional(),
+  priority: IssuePrioritySchema.optional(),
+  tags: z4.array(z4.string()).optional()
+});
+var IssueListResponseSchema = PaginatedResponseSchema(IssueResponseSchema);
+
+// src/settings.ts
+import { z as z5 } from "zod";
+var SettingsResponseSchema = z5.object({
+  githubUsername: z5.string().nullable(),
+  githubToken: z5.string().nullable(),
+  hasGithubToken: z5.boolean(),
+  baseModel: z5.string(),
+  apiKey: z5.string().nullable(),
+  hasApiKey: z5.boolean(),
+  apiEndpoint: z5.string(),
+  proxyUrl: z5.string().nullable(),
+  proxyEnabled: z5.boolean(),
+  reposPath: z5.string().nullable()
+});
+var SettingsUpdateSchema = z5.object({
+  githubUsername: z5.string().optional(),
+  githubToken: z5.string().optional(),
+  baseModel: z5.string().optional(),
+  apiKey: z5.string().optional(),
+  apiEndpoint: z5.string().optional(),
+  proxyUrl: z5.string().optional(),
+  proxyEnabled: z5.boolean().optional(),
+  reposPath: z5.string().optional()
+});
+var GitHubVerifyRequestSchema = z5.object({
+  githubToken: z5.string().min(1),
+  githubUsername: z5.string().optional()
+});
+var GitHubVerifyResponseSchema = z5.object({
+  success: z5.boolean(),
+  username: z5.string().optional(),
+  reposCount: z5.number().int().nonnegative().optional(),
+  error: z5.string().optional()
+});
+
+// src/ai-chat.ts
+import { z as z6 } from "zod";
+var AIChatRequestSchema = z6.object({
+  message: z6.string().min(1),
+  cwd: z6.string().optional(),
+  session_id: z6.string().optional()
+});
+var AIMessageSchema = z6.object({
+  id: z6.union([z6.string(), z6.number().int()]),
+  role: z6.enum(["user", "assistant"]),
+  content: z6.string(),
+  createdAt: z6.coerce.date()
+});
+var AIChatResponseSchema = z6.object({
+  sessionId: z6.string(),
+  message: AIMessageSchema
+});
+var AISessionResponseSchema = z6.object({
+  sessionId: z6.string(),
+  messages: z6.array(AIMessageSchema)
+});
+var ThinkingStartEventSchema = z6.object({
+  type: z6.literal("thinking_start")
+});
+var ThinkingDeltaEventSchema = z6.object({
+  type: z6.literal("thinking_delta"),
+  thinking: z6.string()
+});
+var ThinkingEndEventSchema = z6.object({
+  type: z6.literal("thinking_end")
+});
+var ContentDeltaEventSchema = z6.object({
+  type: z6.literal("content_delta"),
+  content: z6.string()
+});
+var ToolStartEventSchema = z6.object({
+  type: z6.literal("tool_start"),
+  tool_use_id: z6.string(),
+  name: z6.string(),
+  input: z6.record(z6.any())
+});
+var ToolResultEventSchema = z6.object({
+  type: z6.literal("tool_result"),
+  tool_use_id: z6.string(),
+  content: z6.string(),
+  is_error: z6.boolean().optional()
+});
+var MessageDoneEventSchema = z6.object({
+  type: z6.literal("message_done")
+});
+var ErrorEventSchema = z6.object({
+  type: z6.literal("error"),
+  message: z6.string()
+});
+var SSEEventSchema = z6.union([
+  ThinkingStartEventSchema,
+  ThinkingDeltaEventSchema,
+  ThinkingEndEventSchema,
+  ContentDeltaEventSchema,
+  ToolStartEventSchema,
+  ToolResultEventSchema,
+  MessageDoneEventSchema,
+  ErrorEventSchema
+]);
+
+// src/github.ts
+import { z as z7 } from "zod";
+var RepositorySchema = z7.object({
+  id: z7.number().int().positive(),
+  name: z7.string(),
+  full_name: z7.string(),
+  description: z7.string().nullable(),
+  clone_url: z7.string().url(),
+  default_branch: z7.string(),
+  stargazers_count: z7.number().int().nonnegative(),
+  forks_count: z7.number().int().nonnegative(),
+  private: z7.boolean()
+});
+var BranchSchema = z7.object({
+  name: z7.string()
+});
+var RepoOptionSchema = z7.object({
+  value: z7.string(),
+  // full_name
+  label: z7.string(),
+  // full_name
+  description: z7.string().nullable()
+});
+var BranchOptionSchema = z7.object({
+  value: z7.string(),
+  // branch name
+  label: z7.string()
+  // branch name
+});
+var GitHubReposResponseSchema = z7.object({
+  repos: z7.array(RepoOptionSchema)
+});
+var GitHubBranchesResponseSchema = z7.object({
+  branches: z7.array(BranchOptionSchema)
+});
+
+// src/template.ts
+import { z as z8 } from "zod";
+var IssueTemplateListItemSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  description: z8.string()
+});
+var IssueTemplateSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  description: z8.string(),
+  body: z8.string()
+});
+var IssueTemplateListResponseSchema = z8.object({
+  templates: z8.array(IssueTemplateListItemSchema)
+});
+
+// src/utils.ts
+import { z as z9 } from "zod";
+var RetryOptionsSchema = z9.object({
+  maxRetries: z9.number().int().nonnegative().default(3),
+  delayMs: z9.number().int().positive().default(1e3),
+  backoffMultiplier: z9.number().positive().default(2),
+  onRetry: z9.function(z9.tuple([z9.instanceof(Error), z9.number().int()]), z9.void()).optional()
+});
+
+// src/worktree.ts
+import { z as z10 } from "zod";
+var WorktreeCreateRequestSchema = z10.object({
+  branch: z10.string().min(1),
+  force: z10.boolean().optional()
+});
+var WorktreeDeleteRequestSchema = z10.object({
+  issueId: z10.string().min(1)
+});
+var WorktreeStatusResponseSchema = z10.object({
+  issueId: z10.string(),
+  status: WorktreeStatusSchema,
+  path: z10.string().nullable(),
+  branchName: z10.string().nullable(),
+  error: z10.string().nullable()
+});
+export {
+  AI,
+  AIChatRequestSchema,
+  AIChatResponseSchema,
+  AIMessageSchema,
+  AISessionResponseSchema,
+  API_BASE,
+  API_ROUTES,
+  BranchOptionSchema,
+  BranchSchema,
+  ContentDeltaEventSchema,
+  ErrorEventSchema,
+  GITHUB,
+  GitHubBranchesResponseSchema,
+  GitHubReposResponseSchema,
+  GitHubVerifyRequestSchema,
+  GitHubVerifyResponseSchema,
+  HEALTH,
+  ISSUES,
+  ISSUE_TEMPLATES,
+  IssueCreateSchema,
+  IssueListResponseSchema,
+  IssuePrioritySchema,
+  IssueResponseSchema,
+  IssueStatsSchema,
+  IssueStatusSchema,
+  IssueTemplateListItemSchema,
+  IssueTemplateListResponseSchema,
+  IssueTemplateSchema,
+  IssueUpdateSchema,
+  MessageDoneEventSchema,
+  PROJECTS,
+  PaginatedResponseSchema,
+  PaginationQuerySchema,
+  ProjectCreateSchema,
+  ProjectListResponseSchema,
+  ProjectResponseSchema,
+  ProjectUpdateSchema,
+  RepoOptionSchema,
+  RepositorySchema,
+  RetryOptionsSchema,
+  SETTINGS,
+  SSEEventSchema,
+  SettingsResponseSchema,
+  SettingsUpdateSchema,
+  SyncStatusSchema,
+  TASKS,
+  TaskCreateSchema,
+  TaskListResponseSchema,
+  TaskResponseSchema,
+  TaskStatusSchema,
+  TaskUpdateSchema,
+  ThinkingDeltaEventSchema,
+  ThinkingEndEventSchema,
+  ThinkingStartEventSchema,
+  ToolResultEventSchema,
+  ToolStartEventSchema,
+  WORKTREE,
+  WorktreeCreateRequestSchema,
+  WorktreeDeleteRequestSchema,
+  WorktreeStatusResponseSchema,
+  WorktreeStatusSchema
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@fixerorg/schemas",
+  "version": "1.0.0",
+  "description": "Shared schemas for Fixer - AI-powered Issue Management System",
+  "author": "zhangyingwei",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "prepublishOnly": "pnpm build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zhangyingwei/superdev.git",
+    "directory": "packages/schemas"
+  },
+  "dependencies": {
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  }
+}