@happyvertical/smrt-projects 0.30.0

package/dist/index.js

@@ -0,0 +1,2477 @@
+import { ObjectRegistry, foreignKey, smrt, SmrtObject, config, SmrtCollection } from "@happyvertical/smrt-core";
+import { getAI } from "@happyvertical/ai";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+import { loadEnvConfig } from "@happyvertical/utils";
+import { createLogger } from "@happyvertical/logger";
+import { getProject } from "@happyvertical/projects";
+import { getModuleConfig } from "@happyvertical/smrt-config";
+import { getRepository } from "@happyvertical/repos";
+import { PROJECTS_MODULE_META, PROJECTS_UI_SLOTS } from "./ui.js";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const SYNC_THROTTLE_MS = 5 * 60 * 1e3;
+const issueIncorporateFeedbackPrompt = definePrompt({
+  key: "projects.issue.incorporateFeedback",
+  template: `You are updating a specification document based on team feedback.
+
+Current specification:
+{body}
+
+Team comments and feedback:
+{comments}
+
+Instructions:
+1. Analyze the comments for consensus, changes, and new requirements
+2. Update the specification to reflect the agreed-upon changes
+3. Maintain the original structure and formatting where possible
+4. Mark any conflicting feedback that needs resolution
+5. Return ONLY the updated specification text, no additional commentary`,
+  ai: {
+    temperature: 0.2
+  },
+  editable: {
+    template: true,
+    profile: true,
+    model: true,
+    params: true
+  }
+});
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$4(target, key, result);
+  return result;
+};
+let Issue = class extends SmrtObject {
+  tenantId = null;
+  repositoryId;
+  /**
+   * Issue number (provider-specific)
+   */
+  number = 0;
+  /**
+   * Node ID for GraphQL operations (GitHub Projects API)
+   */
+  nodeId = "";
+  /**
+   * Issue title
+   */
+  title = "";
+  /**
+   * Issue body/description
+   */
+  body = "";
+  /**
+   * Issue state
+   */
+  state = "open";
+  /**
+   * Author's login/username
+   */
+  author = "";
+  /**
+   * Labels attached to the issue
+   */
+  labels = [];
+  /**
+   * Assignee logins
+   */
+  assignees = [];
+  /**
+   * Number of comments on the issue
+   */
+  commentsCount = 0;
+  /**
+   * Last sync timestamp
+   */
+  lastSyncedAt = null;
+  /**
+   * Original body before any AI synthesis (for rollback)
+   */
+  originalBody = "";
+  /**
+   * Number of times feedback has been incorporated
+   */
+  synthesisCount = 0;
+  /**
+   * Transient: Cached repository (not persisted)
+   * Protected so PullRequest can access it
+   */
+  _repository;
+  /**
+   * Transient: Cached client (not persisted)
+   */
+  _client;
+  constructor(options = {}) {
+    super(options);
+    if (options.repositoryId !== void 0)
+      this.repositoryId = options.repositoryId;
+    if (options.number !== void 0) this.number = options.number;
+    if (options.nodeId !== void 0) this.nodeId = options.nodeId;
+    if (options.title !== void 0) this.title = options.title;
+    if (options.body !== void 0) this.body = options.body;
+    if (options.state !== void 0) this.state = options.state;
+    if (options.author !== void 0) this.author = options.author;
+    if (options.labels !== void 0) this.labels = options.labels;
+    if (options.assignees !== void 0) this.assignees = options.assignees;
+    if (options.commentsCount !== void 0)
+      this.commentsCount = options.commentsCount;
+    if (options.lastSyncedAt !== void 0)
+      this.lastSyncedAt = options.lastSyncedAt;
+    if (options.originalBody !== void 0)
+      this.originalBody = options.originalBody;
+    if (options.synthesisCount !== void 0)
+      this.synthesisCount = options.synthesisCount;
+    if (options.tenantId !== void 0)
+      this.tenantId = options.tenantId;
+  }
+  /**
+   * Get the repository this issue belongs to
+   */
+  async getRepository() {
+    if (this._repository) {
+      return this._repository;
+    }
+    if (!this.repositoryId) {
+      throw new Error("Issue has no repositoryId set");
+    }
+    const { RepositoryCollection: RepositoryCollection2 } = await Promise.resolve().then(() => Repositories);
+    const collection = await RepositoryCollection2.create(this.options);
+    const repo = await collection.get({ id: this.repositoryId });
+    if (!repo) {
+      throw new Error(`Repository ${this.repositoryId} not found`);
+    }
+    this._repository = repo;
+    return repo;
+  }
+  /**
+   * Get the repository client for API operations
+   */
+  async getClient() {
+    if (this._client) {
+      return this._client;
+    }
+    const repo = await this.getRepository();
+    this._client = await repo.getClient();
+    return this._client;
+  }
+  /**
+   * Clear cached repository and client
+   */
+  clearCache() {
+    this._repository = void 0;
+    this._client = void 0;
+  }
+  /**
+   * Sync issue data from the provider
+   *
+   * @param options - Sync options
+   * @returns This issue with updated fields
+   */
+  async sync(options = {}) {
+    if (!options.force && this.lastSyncedAt && Date.now() - this.lastSyncedAt.getTime() < SYNC_THROTTLE_MS) {
+      return this;
+    }
+    const client = await this.getClient();
+    const issueData = await client.getIssue(this.number);
+    this.nodeId = issueData.id;
+    this.title = issueData.title;
+    this.body = issueData.body;
+    this.state = issueData.state;
+    this.author = issueData.author.login;
+    this.labels = issueData.labels.map((l) => l.name);
+    this.assignees = issueData.assignees.map((a) => a.login);
+    this.commentsCount = issueData.commentsCount;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    return this;
+  }
+  /**
+   * Get comments on this issue
+   *
+   * @returns Array of Comment objects (SMRT models)
+   */
+  async getComments() {
+    const client = await this.getClient();
+    const comments = await client.listComments(this.number);
+    const { Comment: CommentClass } = await Promise.resolve().then(() => Comment$1);
+    return comments.map(
+      (c) => new CommentClass({
+        ...this.options,
+        issueId: this.id ?? void 0,
+        commentId: c.id,
+        body: c.body,
+        author: c.author.login,
+        createdAt: c.createdAt,
+        updatedAt: c.updatedAt,
+        url: c.url
+      })
+    );
+  }
+  /**
+   * Add a comment to this issue
+   *
+   * @param body - Comment body text
+   * @returns Created Comment (SMRT model)
+   */
+  async addComment(body) {
+    const client = await this.getClient();
+    const created = await client.addComment(this.number, body);
+    const { Comment: CommentClass } = await Promise.resolve().then(() => Comment$1);
+    const comment = new CommentClass({
+      ...this.options,
+      issueId: this.id ?? void 0,
+      commentId: created.id,
+      body: created.body,
+      author: created.author.login,
+      createdAt: created.createdAt,
+      updatedAt: created.updatedAt,
+      url: created.url
+    });
+    await comment.save();
+    this.commentsCount++;
+    await this.save();
+    return comment;
+  }
+  /**
+   * Incorporate feedback from comments into the issue body
+   *
+   * This is the core "Living Spec" functionality:
+   * 1. Reads all comments on the issue
+   * 2. Uses AI to synthesize comments with the current body
+   * 3. Optionally updates the issue with the synthesized content
+   *
+   * @param options - Feedback incorporation options
+   * @returns Result with synthesized content and status
+   */
+  async incorporateFeedback(options = {}) {
+    const comments = await this.getComments();
+    let relevantComments = comments;
+    if (options.since) {
+      const sinceDate = options.since;
+      relevantComments = comments.filter(
+        (c) => c.createdAt && c.createdAt > sinceDate
+      );
+    }
+    if (relevantComments.length === 0) {
+      return {
+        synthesized: this.body,
+        applied: false,
+        commentsAnalyzed: 0
+      };
+    }
+    const resolvedPrompt = await resolvePrompt(
+      issueIncorporateFeedbackPrompt.key,
+      {
+        db: this.options.db ?? this.options.persistence,
+        tenantId: this.tenantId,
+        variables: {
+          body: this.body,
+          comments: relevantComments.map((c) => `- ${c.author}: ${c.body}`).join("\n")
+        },
+        override: options.prompt ? { template: options.prompt } : void 0
+      }
+    );
+    const aiOptions = {
+      ...resolvedPrompt.ai.params,
+      ...resolvedPrompt.ai.model ? { model: resolvedPrompt.ai.model } : {}
+    };
+    let synthesized;
+    if (resolvedPrompt.ai.provider) {
+      synthesized = await this.runPromptWithResolvedAI(
+        resolvedPrompt.text,
+        resolvedPrompt.ai.provider,
+        aiOptions
+      );
+    } else {
+      synthesized = await this.do(resolvedPrompt.text, {
+        ...aiOptions,
+        includeData: false
+      });
+    }
+    const result = {
+      synthesized,
+      applied: false,
+      commentsAnalyzed: relevantComments.length,
+      previousBody: this.body
+    };
+    if (options.apply) {
+      if (this.synthesisCount === 0) {
+        this.originalBody = this.body;
+      }
+      const client = await this.getClient();
+      await client.updateIssue(this.number, { body: synthesized });
+      this.body = synthesized;
+      this.synthesisCount++;
+      this.lastSyncedAt = /* @__PURE__ */ new Date();
+      await this.save();
+      result.applied = true;
+    }
+    return result;
+  }
+  async runPromptWithResolvedAI(instructions, provider, options) {
+    const aiOption = this.options.ai;
+    if (this.isExplicitAiClientOption(aiOption)) {
+      const ai2 = await this.getAiClient();
+      return this.sendPromptMessage(ai2, instructions, options);
+    }
+    const globalAiConfig = config.toJSON().ai || {};
+    const instanceAiConfig = aiOption ?? {};
+    const aiConfig = loadEnvConfig(
+      {
+        ...globalAiConfig,
+        ...instanceAiConfig
+      },
+      {
+        packageName: "ai",
+        prefix: "SMRT",
+        schema: {
+          provider: "string",
+          model: "string",
+          apiKey: "string",
+          timeout: "number",
+          maxRetries: "number",
+          temperature: "number",
+          maxTokens: "number"
+        }
+      }
+    );
+    const env = process.env;
+    const apiKey = aiConfig.apiKey || (provider === "anthropic" ? env.ANTHROPIC_API_KEY : provider === "gemini" ? env.GEMINI_API_KEY : env.OPENAI_API_KEY);
+    const ai = await getAI({
+      ...aiConfig,
+      provider,
+      type: provider,
+      model: options.model ?? aiConfig.model,
+      defaultModel: options.model ?? aiConfig.model,
+      apiKey
+    });
+    return this.sendPromptMessage(ai, instructions, options);
+  }
+  /**
+   * Sends a fully-resolved instruction string to the given AI client.
+   *
+   * `incorporateFeedback()` curates the entire prompt (issue body + comments)
+   * via the resolved prompt template, so this path deliberately does NOT inject
+   * the object's own field data — that would duplicate the body. The `this.do()`
+   * fallback path passes `includeData: false` for the same reason, keeping both
+   * `incorporateFeedback()` paths consistent (#1567).
+   */
+  async sendPromptMessage(ai, instructions, options) {
+    const prompt = `--- Beginning of instructions ---
+${instructions}
+--- End of instructions ---
+Based on the content body, please follow the instructions and provide a response. Never make use of codeblocks.`;
+    const tools = this.getAvailableTools();
+    return await ai.message(prompt, {
+      ...options,
+      tools: tools.length > 0 ? tools : void 0
+    });
+  }
+  isExplicitAiClientOption(aiOption) {
+    return !!(aiOption && typeof aiOption === "object" && typeof aiOption.embed === "function" && !aiOption.provider && !aiOption.type);
+  }
+  /**
+   * Rollback to the original body before AI synthesis
+   *
+   * @returns Result with success status
+   */
+  async rollback() {
+    if (!this.originalBody) {
+      return {
+        success: false,
+        message: "No original body to rollback to"
+      };
+    }
+    if (this.synthesisCount === 0) {
+      return {
+        success: false,
+        message: "No synthesis has been applied"
+      };
+    }
+    const client = await this.getClient();
+    await client.updateIssue(this.number, { body: this.originalBody });
+    this.body = this.originalBody;
+    this.originalBody = "";
+    this.synthesisCount = 0;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    return {
+      success: true,
+      message: "Successfully rolled back to original body"
+    };
+  }
+  /**
+   * AI-powered: Check if this issue needs review
+   *
+   * @returns True if the issue likely needs attention
+   */
+  async needsReview() {
+    return await this.is(
+      `This issue needs review because one or more of the following:
+      - It has been open for a long time without updates
+      - There are unresolved questions in the comments
+      - The requirements are unclear or incomplete
+      - There is conflicting feedback that needs resolution`
+    );
+  }
+  /**
+   * AI-powered: Check if the issue is a bug report
+   */
+  async isBugReport() {
+    return await this.is(
+      "This issue describes a bug, defect, or unexpected behavior"
+    );
+  }
+  /**
+   * AI-powered: Check if the issue is a feature request
+   */
+  async isFeatureRequest() {
+    return await this.is(
+      "This issue is a feature request or enhancement proposal"
+    );
+  }
+  /**
+   * AI-powered: Generate suggested labels based on content
+   *
+   * @returns Array of suggested label names
+   */
+  async suggestLabels() {
+    const suggestion = await this.do(
+      `Based on the issue title and body, suggest appropriate labels.
+      Consider:
+      - Type: bug, feature, docs, chore, test
+      - Priority: P0 (critical), P1 (high), P2 (medium), P3 (low)
+      - Area: specific code areas or components
+
+      Return only a comma-separated list of labels, nothing else.`
+    );
+    return suggestion.split(",").map((l) => l.trim()).filter(Boolean);
+  }
+  /**
+   * Close this issue
+   */
+  async close() {
+    const client = await this.getClient();
+    await client.closeIssue(this.number);
+    this.state = "closed";
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Add labels to this issue
+   *
+   * @param labels - Label names to add
+   */
+  async addLabels(labels) {
+    const client = await this.getClient();
+    await client.addLabels(this.number, labels);
+    this.labels = [.../* @__PURE__ */ new Set([...this.labels, ...labels])];
+    await this.save();
+  }
+  /**
+   * Remove a label from this issue
+   *
+   * @param label - Label name to remove
+   */
+  async removeLabel(label) {
+    const client = await this.getClient();
+    await client.removeLabel(this.number, label);
+    this.labels = this.labels.filter((l) => l !== label);
+    await this.save();
+  }
+  /**
+   * Assign users to this issue
+   *
+   * @param assignees - User logins to assign
+   */
+  async assign(assignees) {
+    const client = await this.getClient();
+    await client.assignIssue(this.number, assignees);
+    this.assignees = [.../* @__PURE__ */ new Set([...this.assignees, ...assignees])];
+    await this.save();
+  }
+  /**
+   * Get issue URL
+   */
+  getUrl() {
+    const repo = this._repository;
+    if (repo) {
+      return `https://github.com/${repo.owner}/${repo.name}/issues/${this.number}`;
+    }
+    return "";
+  }
+};
+__decorateClass$5([
+  tenantId({ nullable: true })
+], Issue.prototype, "tenantId", 2);
+__decorateClass$5([
+  foreignKey("Repository", { required: true })
+], Issue.prototype, "repositoryId", 2);
+Issue = __decorateClass$5([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "sync", "incorporateFeedback"] },
+    // sync/incorporateFeedback/rollback are operator commands invoked in-process
+    // via the CLI; they intentionally aren't exposed over HTTP today.
+    cli: {
+      include: ["list", "get", "sync", "incorporateFeedback", "rollback"],
+      skipApiCheck: true
+    }
+  })
+], Issue);
+const Issue$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get Issue() {
+    return Issue;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+class IssueCollection extends SmrtCollection {
+  static _itemClass = Issue;
+  /**
+   * Discover issues from a repository and sync to database
+   *
+   * This method:
+   * 1. Fetches issues from the provider via SDK
+   * 2. Creates/updates SMRT Issue records in the database
+   * 3. Returns the synced Issue objects
+   *
+   * @param options - Discovery options
+   * @returns Array of Issue objects
+   */
+  async discover(options) {
+    const { repository, filters } = options;
+    const repositoryId = repository.id ?? void 0;
+    if (!repositoryId) {
+      throw new Error("Repository must be saved before discovering issues");
+    }
+    const repoClient = await repository.getClient();
+    const remoteIssues = await repoClient.searchIssues("", filters);
+    const issues = [];
+    for (const remote of remoteIssues) {
+      let issue = await this.findOne({
+        where: {
+          repositoryId,
+          number: remote.number
+        }
+      });
+      if (!issue) {
+        issue = await this.create({
+          repositoryId,
+          number: remote.number,
+          nodeId: remote.id,
+          title: remote.title,
+          body: remote.body,
+          state: remote.state,
+          author: remote.author.login,
+          labels: remote.labels.map((l) => l.name),
+          assignees: remote.assignees.map((a) => a.login),
+          commentsCount: remote.commentsCount,
+          lastSyncedAt: /* @__PURE__ */ new Date()
+        });
+      } else {
+        issue.nodeId = remote.id;
+        issue.title = remote.title;
+        issue.body = remote.body;
+        issue.state = remote.state;
+        issue.author = remote.author.login;
+        issue.labels = remote.labels.map((l) => l.name);
+        issue.assignees = remote.assignees.map((a) => a.login);
+        issue.commentsCount = remote.commentsCount;
+        issue.lastSyncedAt = /* @__PURE__ */ new Date();
+      }
+      await issue.save();
+      issues.push(issue);
+    }
+    return issues;
+  }
+  /**
+   * Find issues by repository
+   *
+   * @param repositoryId - Repository ID
+   * @returns Array of issues
+   */
+  async findByRepository(repositoryId) {
+    return await this.list({
+      where: { repositoryId }
+    });
+  }
+  /**
+   * Find open issues
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of open issues
+   */
+  async findOpen(repositoryId) {
+    const where = { state: "open" };
+    if (repositoryId) {
+      where.repositoryId = repositoryId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Find issues by label
+   *
+   * @param label - Label name
+   * @param repositoryId - Optional repository filter
+   * @returns Array of issues with the label
+   */
+  async findByLabel(label, repositoryId) {
+    const issues = await this.list({
+      where: repositoryId ? { repositoryId } : {}
+    });
+    return issues.filter((issue) => issue.labels.includes(label));
+  }
+  /**
+   * Find issues by assignee
+   *
+   * @param assignee - Assignee login
+   * @param repositoryId - Optional repository filter
+   * @returns Array of issues assigned to the user
+   */
+  async findByAssignee(assignee, repositoryId) {
+    const issues = await this.list({
+      where: repositoryId ? { repositoryId } : {}
+    });
+    return issues.filter((issue) => issue.assignees.includes(assignee));
+  }
+  /**
+   * Find issues needing review (AI-powered)
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of issues that need review
+   */
+  async findNeedingReview(repositoryId) {
+    const openIssues = await this.findOpen(repositoryId);
+    const needingReview = [];
+    for (const issue of openIssues) {
+      if (await issue.needsReview()) {
+        needingReview.push(issue);
+      }
+    }
+    return needingReview;
+  }
+  /**
+   * Find issue by number in a repository
+   *
+   * @param repositoryId - Repository ID
+   * @param number - Issue number
+   * @returns Issue or null
+   */
+  async findByNumber(repositoryId, number) {
+    const results = await this.list({
+      where: { repositoryId, number },
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Get issues with unincorporated feedback
+   *
+   * Issues that have comments but haven't had feedback incorporated
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of issues
+   */
+  async findWithUnincorporatedFeedback(repositoryId) {
+    const issues = await this.findOpen(repositoryId);
+    return issues.filter(
+      (issue) => issue.commentsCount > 0 && issue.synthesisCount === 0
+    );
+  }
+  /**
+   * Batch sync issues from repository
+   *
+   * @param repository - Repository to sync from
+   * @param options - Sync options
+   * @returns Array of synced issues
+   */
+  async batchSync(repository, options = {}) {
+    const issues = await this.findByRepository(repository.id);
+    const synced = [];
+    for (const issue of issues) {
+      await issue.sync(options);
+      synced.push(issue);
+    }
+    return synced;
+  }
+  /**
+   * Find issues by tenant ID
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of issues for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global issues (no tenant)
+   *
+   * @returns Array of global issues
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find issues for a tenant including global issues
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of tenant and global issues
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Issues = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IssueCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$3(target, key, result);
+  return result;
+};
+let Project = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Provider-specific project ID (e.g., GitHub GraphQL node ID)
+   */
+  projectId = "";
+  /**
+   * Human-readable project number
+   */
+  projectNumber = 0;
+  /**
+   * Project title
+   */
+  title = "";
+  /**
+   * Project description
+   */
+  description = "";
+  /**
+   * Project owner (organization or user)
+   */
+  owner = "";
+  /**
+   * Project URL
+   */
+  url = "";
+  /**
+   * Project provider type
+   */
+  providerType = "github";
+  /**
+   * Environment variable name or config key for token resolution
+   */
+  tokenConfigKey = "GITHUB_TOKEN";
+  /**
+   * Available statuses (columns) in the project
+   */
+  statuses = [];
+  /**
+   * Custom fields defined in the project
+   */
+  fields = [];
+  /**
+   * Status field ID for GitHub Projects V2
+   */
+  statusFieldId = "";
+  /**
+   * Maps status name to option ID (for GitHub Projects V2)
+   */
+  statusOptions = {};
+  /**
+   * Last sync timestamp
+   */
+  lastSyncedAt = null;
+  /**
+   * Transient: Cached project client (not persisted)
+   */
+  _client;
+  constructor(options = {}) {
+    super(options);
+    if (options.projectId !== void 0) this.projectId = options.projectId;
+    if (options.projectNumber !== void 0)
+      this.projectNumber = options.projectNumber;
+    if (options.title !== void 0) this.title = options.title;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.owner !== void 0) this.owner = options.owner;
+    if (options.url !== void 0) this.url = options.url;
+    if (options.providerType !== void 0)
+      this.providerType = options.providerType;
+    if (options.tokenConfigKey !== void 0)
+      this.tokenConfigKey = options.tokenConfigKey;
+    if (options.statuses !== void 0) this.statuses = options.statuses;
+    if (options.fields !== void 0) this.fields = options.fields;
+    if (options.statusFieldId !== void 0)
+      this.statusFieldId = options.statusFieldId;
+    if (options.statusOptions !== void 0)
+      this.statusOptions = options.statusOptions;
+    if (options.tenantId !== void 0)
+      this.tenantId = options.tenantId;
+  }
+  /**
+   * Get the project client, resolving token from config
+   *
+   * @returns Project client for API operations
+   * @throws Error if token cannot be resolved
+   */
+  async getClient() {
+    if (this._client) {
+      return this._client;
+    }
+    const token = process.env[this.tokenConfigKey] || getModuleConfig("smrt-projects", {})[this.tokenConfigKey];
+    if (!token) {
+      throw new Error(
+        `Token not found for key '${this.tokenConfigKey}'. Set the ${this.tokenConfigKey} environment variable or configure it in smrt.config.`
+      );
+    }
+    this._client = await getProject({
+      type: this.providerType,
+      projectId: this.projectId,
+      token,
+      statusFieldId: this.statusFieldId || void 0,
+      statusOptions: Object.keys(this.statusOptions).length > 0 ? this.statusOptions : void 0
+    });
+    return this._client;
+  }
+  /**
+   * Clear the cached client
+   */
+  clearClient() {
+    this._client = void 0;
+  }
+  /**
+   * Sync project metadata from the provider
+   *
+   * @param options - Sync options
+   * @returns This project with updated fields
+   */
+  async sync(options = {}) {
+    if (!options.force && this.lastSyncedAt && Date.now() - this.lastSyncedAt.getTime() < SYNC_THROTTLE_MS) {
+      return this;
+    }
+    const client = await this.getClient();
+    const projectData = await client.getProject();
+    this.title = projectData.title;
+    this.description = projectData.description || "";
+    this.owner = projectData.owner;
+    this.url = projectData.url;
+    this.statuses = projectData.statuses;
+    this.fields = projectData.fields;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    return this;
+  }
+  /**
+   * Add an issue or PR to this project
+   *
+   * @param item - Issue or PullRequest to add
+   * @returns Created ProjectItem
+   */
+  async addItem(item) {
+    if (!item.nodeId) {
+      throw new Error("Item must have a nodeId (sync the item first)");
+    }
+    const client = await this.getClient();
+    return await client.addItem(item.nodeId);
+  }
+  /**
+   * Remove an item from this project
+   *
+   * @param itemId - Project item ID to remove
+   */
+  async removeItem(itemId) {
+    const client = await this.getClient();
+    await client.removeItem(itemId);
+  }
+  /**
+   * Get a specific item from the project
+   *
+   * @param itemId - Project item ID
+   * @returns ProjectItem or null
+   */
+  async getItem(itemId) {
+    const client = await this.getClient();
+    return await client.getItem(itemId);
+  }
+  /**
+   * List items in this project
+   *
+   * @param filters - Optional filters
+   * @returns Array of ProjectItems
+   */
+  async listItems(filters) {
+    const client = await this.getClient();
+    return await client.listItems(filters);
+  }
+  /**
+   * Update an item's status (column)
+   *
+   * @param itemId - Project item ID
+   * @param status - New status name
+   */
+  async updateItemStatus(itemId, status) {
+    const client = await this.getClient();
+    await client.updateItemStatus(itemId, status);
+  }
+  /**
+   * Update an item's custom field
+   *
+   * @param itemId - Project item ID
+   * @param fieldId - Field ID
+   * @param value - New value
+   */
+  async updateItemField(itemId, fieldId, value) {
+    const client = await this.getClient();
+    await client.updateItemField(itemId, fieldId, value);
+  }
+  /**
+   * Get available statuses
+   *
+   * @returns Array of status definitions
+   */
+  async getStatuses() {
+    if (this.statuses.length > 0) {
+      return this.statuses;
+    }
+    const client = await this.getClient();
+    this.statuses = await client.listStatuses();
+    await this.save();
+    return this.statuses;
+  }
+  /**
+   * Get available fields
+   *
+   * @returns Array of field definitions
+   */
+  async getFields() {
+    if (this.fields.length > 0) {
+      return this.fields;
+    }
+    const client = await this.getClient();
+    this.fields = await client.listFields();
+    await this.save();
+    return this.fields;
+  }
+  /**
+   * Get items in a specific status/column
+   *
+   * @param status - Status name
+   * @returns Array of ProjectItems in that status
+   */
+  async getItemsByStatus(status) {
+    return await this.listItems({ status });
+  }
+  /**
+   * Move an item to a new status
+   *
+   * @param item - Issue or PullRequest
+   * @param status - Target status name
+   */
+  async moveItem(item, status) {
+    const items = await this.listItems();
+    const projectItem = items.find((i) => i.contentId === item.nodeId);
+    if (!projectItem) {
+      throw new Error("Item not found in project");
+    }
+    await this.updateItemStatus(projectItem.id, status);
+  }
+  /**
+   * AI-powered: Analyze project health and suggest improvements
+   *
+   * @returns Analysis of project status
+   */
+  async analyzeHealth() {
+    const items = await this.listItems();
+    const statuses = await this.getStatuses();
+    const statusCounts = {};
+    for (const status of statuses) {
+      statusCounts[status.name] = items.filter(
+        (i) => i.status === status.name
+      ).length;
+    }
+    return await this.do(
+      `Analyze the health of this project board and suggest improvements.
+
+      Project: ${this.title}
+      Description: ${this.description}
+
+      Item distribution by status:
+      ${Object.entries(statusCounts).map(([status, count]) => `- ${status}: ${count} items`).join("\n")}
+
+      Total items: ${items.length}
+
+      Provide:
+      1. Overall health assessment
+      2. Potential bottlenecks
+      3. Suggestions for improvement`,
+      // Title/description/status counts hand-rolled above; skip do()'s
+      // object-data injection so the board context is not duplicated.
+      { includeData: false }
+    );
+  }
+  /**
+   * Get project by title
+   *
+   * @param title - Project title
+   * @param options - Additional options
+   * @returns Project or null
+   */
+  static async getByTitle(title, options = {}) {
+    const { ProjectCollection: ProjectCollection2 } = await Promise.resolve().then(() => Projects);
+    const collection = await ProjectCollection2.create(options);
+    return await collection.findByTitle(title);
+  }
+};
+__decorateClass$4([
+  tenantId({ nullable: true })
+], Project.prototype, "tenantId", 2);
+Project = __decorateClass$4([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "sync", "addItem", "updateItemStatus"] },
+    // sync/addItem/updateItemStatus/listItems are operator commands invoked
+    // in-process via the CLI; they intentionally aren't exposed over HTTP today.
+    cli: {
+      include: [
+        "list",
+        "get",
+        "sync",
+        "addItem",
+        "updateItemStatus",
+        "listItems"
+      ],
+      skipApiCheck: true
+    }
+  })
+], Project);
+const logger$3 = createLogger({ level: "info" });
+class ProjectCollection extends SmrtCollection {
+  static _itemClass = Project;
+  /**
+   * Find project by title
+   *
+   * @param title - Project title
+   * @returns Project or null
+   */
+  async findByTitle(title) {
+    const results = await this.list({
+      where: { title },
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Find projects by owner
+   *
+   * @param owner - Project owner (organization or user)
+   * @returns Array of projects
+   */
+  async findByOwner(owner) {
+    return await this.list({
+      where: { owner }
+    });
+  }
+  /**
+   * Find projects by provider type
+   *
+   * @param providerType - Provider type
+   * @returns Array of projects
+   */
+  async findByProvider(providerType) {
+    return await this.list({
+      where: { providerType }
+    });
+  }
+  /**
+   * Get or create a project by ID
+   *
+   * @param projectId - Provider-specific project ID
+   * @param options - Additional options for creation
+   * @returns Project (existing or newly created)
+   */
+  async getOrCreate(projectId, options = {}) {
+    let project = await this.findOne({
+      where: { projectId }
+    });
+    if (!project) {
+      project = await this.create({
+        projectId,
+        title: options.title || "",
+        owner: options.owner || "",
+        providerType: options.providerType || "github",
+        tokenConfigKey: options.tokenConfigKey || "GITHUB_TOKEN",
+        statusFieldId: options.statusFieldId || "",
+        statusOptions: options.statusOptions || {}
+      });
+      await project.save();
+      await project.sync({ force: true });
+    }
+    return project;
+  }
+  /**
+   * Sync all projects
+   *
+   * @param options - Sync options
+   * @returns Array of synced projects
+   */
+  async syncAll(options = {}) {
+    const projects = await this.list({});
+    const synced = [];
+    for (const project of projects) {
+      await project.sync(options);
+      synced.push(project);
+    }
+    return synced;
+  }
+  /**
+   * Find projects with items in a specific status
+   *
+   * @param status - Status name
+   * @returns Array of projects
+   */
+  async findWithItemsInStatus(status) {
+    const projects = await this.list({});
+    const matching = [];
+    for (const project of projects) {
+      try {
+        const items = await project.getItemsByStatus(status);
+        if (items.length > 0) {
+          matching.push(project);
+        }
+      } catch (error) {
+        logger$3.warn(`Error accessing items for project ${project.projectId}`, {
+          error: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    return matching;
+  }
+  /**
+   * Get project statistics
+   *
+   * @param projectId - Project ID
+   * @returns Statistics object
+   */
+  async getStatistics(projectId) {
+    const project = await this.findOne({ where: { projectId } });
+    if (!project) {
+      throw new Error(`Project ${projectId} not found`);
+    }
+    const items = await project.listItems();
+    const statuses = await project.getStatuses();
+    const itemsByStatus = {};
+    for (const status of statuses) {
+      itemsByStatus[status.name] = 0;
+    }
+    const itemsByType = {
+      Issue: 0,
+      PullRequest: 0,
+      DraftIssue: 0
+    };
+    for (const item of items) {
+      if (item.status && itemsByStatus[item.status] !== void 0) {
+        itemsByStatus[item.status]++;
+      }
+      if (itemsByType[item.type] !== void 0) {
+        itemsByType[item.type]++;
+      }
+    }
+    return {
+      totalItems: items.length,
+      itemsByStatus,
+      itemsByType
+    };
+  }
+  /**
+   * Find projects by tenant ID
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of projects for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global projects (no tenant)
+   *
+   * @returns Array of global projects
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find projects for a tenant including global projects
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of tenant and global projects
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Projects = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ProjectCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let PullRequest = class extends Issue {
+  /**
+   * Source branch ref
+   */
+  headRef = "";
+  /**
+   * Target branch ref
+   */
+  baseRef = "";
+  /**
+   * Whether the PR has been merged
+   */
+  merged = false;
+  /**
+   * When the PR was merged
+   */
+  mergedAt = null;
+  /**
+   * Whether the PR can be merged
+   */
+  mergeable = true;
+  /**
+   * Whether this is a draft PR
+   */
+  draft = false;
+  /**
+   * Lines added
+   */
+  additions = 0;
+  /**
+   * Lines deleted
+   */
+  deletions = 0;
+  /**
+   * Number of files changed
+   */
+  changedFiles = 0;
+  constructor(options = {}) {
+    super(options);
+    if (options.headRef !== void 0) this.headRef = options.headRef;
+    if (options.baseRef !== void 0) this.baseRef = options.baseRef;
+    if (options.merged !== void 0) this.merged = options.merged;
+    if (options.mergedAt !== void 0) this.mergedAt = options.mergedAt;
+    if (options.mergeable !== void 0) this.mergeable = options.mergeable;
+    if (options.draft !== void 0) this.draft = options.draft;
+    if (options.additions !== void 0) this.additions = options.additions;
+    if (options.deletions !== void 0) this.deletions = options.deletions;
+    if (options.changedFiles !== void 0)
+      this.changedFiles = options.changedFiles;
+  }
+  /**
+   * Sync PR data from the provider
+   *
+   * @param options - Sync options
+   * @returns This PR with updated fields
+   */
+  async sync(options = {}) {
+    if (!options.force && this.lastSyncedAt && Date.now() - this.lastSyncedAt.getTime() < SYNC_THROTTLE_MS) {
+      return this;
+    }
+    const client = await this.getClient();
+    const prData = await client.getPullRequest(this.number);
+    this.nodeId = prData.id;
+    this.title = prData.title;
+    this.body = prData.body;
+    this.state = prData.state;
+    this.author = prData.author.login;
+    this.labels = prData.labels.map((l) => l.name);
+    this.assignees = prData.assignees.map((a) => a.login);
+    this.commentsCount = prData.commentsCount;
+    this.headRef = prData.headRef;
+    this.baseRef = prData.baseRef;
+    this.merged = prData.merged;
+    this.mergedAt = prData.mergedAt || null;
+    this.mergeable = prData.mergeable;
+    this.draft = prData.draft;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    return this;
+  }
+  /**
+   * AI-powered: Generate a summary of PR changes
+   *
+   * @returns Summary of what this PR does
+   */
+  async summarize() {
+    return await this.do(
+      `Summarize this pull request concisely.
+
+      Title: ${this.title}
+      Description: ${this.body}
+
+      Changes: ${this.additions} additions, ${this.deletions} deletions across ${this.changedFiles} files
+      Source: ${this.headRef} → ${this.baseRef}
+
+      Provide a 2-3 sentence summary focusing on:
+      1. What the PR does
+      2. Why it matters
+      3. Any notable implementation details`,
+      // Title/body/stats hand-rolled above; skip do()'s object-data injection.
+      { includeData: false }
+    );
+  }
+  /**
+   * Merge this pull request
+   *
+   * @param method - Merge method (merge, squash, rebase)
+   */
+  async merge(method = "squash") {
+    if (this.merged) {
+      throw new Error("Pull request is already merged");
+    }
+    if (this.draft) {
+      throw new Error("Cannot merge a draft pull request");
+    }
+    if (!this.mergeable) {
+      throw new Error("Pull request is not mergeable");
+    }
+    const client = await this.getClient();
+    await client.mergePullRequest(this.number, method);
+    this.merged = true;
+    this.mergedAt = /* @__PURE__ */ new Date();
+    this.state = "closed";
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Mark this draft PR as ready for review
+   */
+  async markReady() {
+    if (!this.draft) {
+      throw new Error("Pull request is not a draft");
+    }
+    const client = await this.getClient();
+    await client.markPRReady(this.number);
+    this.draft = false;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Convert this PR back to draft
+   */
+  async convertToDraft() {
+    if (this.draft) {
+      throw new Error("Pull request is already a draft");
+    }
+    const client = await this.getClient();
+    await client.convertPRToDraft(this.number);
+    this.draft = true;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Request review from specified users
+   *
+   * @param reviewers - User logins to request review from
+   */
+  async requestReviewers(reviewers) {
+    const client = await this.getClient();
+    await client.requestReview(this.number, reviewers);
+  }
+  /**
+   * Find related issue for this PR
+   *
+   * @returns Related Issue or null
+   */
+  async findLinkedIssue() {
+    const client = await this.getClient();
+    const issue = await client.findIssueForPR(this.number);
+    if (!issue) {
+      return null;
+    }
+    const { IssueCollection: IssueCollection2 } = await Promise.resolve().then(() => Issues);
+    const collection = await IssueCollection2.create(this.options);
+    return await collection.findOne({
+      where: { repositoryId: this.repositoryId, number: issue.number }
+    });
+  }
+  /**
+   * AI-powered: Check if this PR is ready to merge
+   *
+   * @returns True if the PR appears ready
+   */
+  async isReadyToMerge() {
+    if (this.draft) return false;
+    if (!this.mergeable) return false;
+    if (this.state === "closed") return false;
+    return await this.is(
+      `This pull request is ready to merge because:
+      - It has a clear description of what it does
+      - It addresses a specific issue or feature
+      - The scope is appropriate (not too large)
+      - There are no unresolved review comments`
+    );
+  }
+  /**
+   * AI-powered: Suggest reviewers based on changed files
+   *
+   * @returns Array of suggested reviewer logins
+   */
+  async suggestReviewers() {
+    const suggestion = await this.do(
+      `Based on this pull request's title, description, and scope,
+      suggest who should review it.
+
+      Title: ${this.title}
+      Description: ${this.body}
+      Changes: ${this.changedFiles} files changed
+
+      Consider:
+      - Code owners for the affected areas
+      - Team members with relevant expertise
+      - People who have previously worked on related code
+
+      Return only a comma-separated list of GitHub usernames, nothing else.
+      If you cannot determine reviewers, return an empty string.`,
+      // Title/description hand-rolled above; skip do()'s object-data injection.
+      { includeData: false }
+    );
+    return suggestion.split(",").map((r) => r.trim()).filter(Boolean);
+  }
+  /**
+   * Get PR URL
+   */
+  getUrl() {
+    const repo = this._repository;
+    if (repo) {
+      return `https://github.com/${repo.owner}/${repo.name}/pull/${this.number}`;
+    }
+    return "";
+  }
+  /**
+   * Get the change size classification
+   *
+   * @returns Size classification (xs, s, m, l, xl)
+   */
+  getChangeSize() {
+    const total = this.additions + this.deletions;
+    if (total < 10) return "xs";
+    if (total < 50) return "s";
+    if (total < 200) return "m";
+    if (total < 500) return "l";
+    return "xl";
+  }
+};
+PullRequest = __decorateClass$3([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "sync", "summarize", "merge"] },
+    // sync/summarize/merge/markReady are operator commands invoked in-process
+    // via the CLI; they intentionally aren't exposed over HTTP today.
+    cli: {
+      include: ["list", "get", "sync", "summarize", "merge", "markReady"],
+      skipApiCheck: true
+    }
+  })
+], PullRequest);
+const PullRequest$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get PullRequest() {
+    return PullRequest;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+const logger$2 = createLogger({ level: "info" });
+class PullRequestCollection extends SmrtCollection {
+  static _itemClass = PullRequest;
+  /**
+   * Discover pull requests from a repository and sync to database
+   *
+   * @param options - Discovery options
+   * @returns Array of PullRequest objects
+   */
+  async discover(options) {
+    const { repository, filters } = options;
+    const repositoryId = repository.id ?? void 0;
+    if (!repositoryId) {
+      throw new Error(
+        "Repository must be saved before discovering pull requests"
+      );
+    }
+    const repoClient = await repository.getClient();
+    const remoteItems = await repoClient.searchIssues("is:pr", filters);
+    const pullRequests = [];
+    for (const remote of remoteItems) {
+      let prData;
+      try {
+        prData = await repoClient.getPullRequest(remote.number);
+      } catch (error) {
+        logger$2.warn(
+          `Failed to fetch PR #${remote.number} from ${repository.owner}/${repository.name}`,
+          { error: error instanceof Error ? error.message : error }
+        );
+        continue;
+      }
+      let pr = await this.findOne({
+        where: {
+          repositoryId,
+          number: remote.number
+        }
+      });
+      if (!pr) {
+        pr = await this.create({
+          repositoryId,
+          number: prData.number,
+          nodeId: prData.id,
+          title: prData.title,
+          body: prData.body,
+          state: prData.state,
+          author: prData.author.login,
+          labels: prData.labels.map((l) => l.name),
+          assignees: prData.assignees.map((a) => a.login),
+          commentsCount: prData.commentsCount,
+          headRef: prData.headRef,
+          baseRef: prData.baseRef,
+          merged: prData.merged,
+          mergedAt: prData.mergedAt || null,
+          mergeable: prData.mergeable,
+          draft: prData.draft,
+          lastSyncedAt: /* @__PURE__ */ new Date()
+        });
+      } else {
+        pr.nodeId = prData.id;
+        pr.title = prData.title;
+        pr.body = prData.body;
+        pr.state = prData.state;
+        pr.author = prData.author.login;
+        pr.labels = prData.labels.map((l) => l.name);
+        pr.assignees = prData.assignees.map((a) => a.login);
+        pr.commentsCount = prData.commentsCount;
+        pr.headRef = prData.headRef;
+        pr.baseRef = prData.baseRef;
+        pr.merged = prData.merged;
+        pr.mergedAt = prData.mergedAt || null;
+        pr.mergeable = prData.mergeable;
+        pr.draft = prData.draft;
+        pr.lastSyncedAt = /* @__PURE__ */ new Date();
+      }
+      await pr.save();
+      pullRequests.push(pr);
+    }
+    return pullRequests;
+  }
+  /**
+   * Find PRs by repository
+   *
+   * @param repositoryId - Repository ID
+   * @returns Array of PRs
+   */
+  async findByRepository(repositoryId) {
+    return await this.list({
+      where: { repositoryId }
+    });
+  }
+  /**
+   * Find open PRs
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of open PRs
+   */
+  async findOpen(repositoryId) {
+    const where = { state: "open" };
+    if (repositoryId) {
+      where.repositoryId = repositoryId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Find draft PRs
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of draft PRs
+   */
+  async findDrafts(repositoryId) {
+    const openPRs = await this.findOpen(repositoryId);
+    return openPRs.filter((pr) => pr.draft);
+  }
+  /**
+   * Find PRs ready to merge
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of mergeable PRs
+   */
+  async findReadyToMerge(repositoryId) {
+    const openPRs = await this.findOpen(repositoryId);
+    return openPRs.filter((pr) => !pr.draft && pr.mergeable);
+  }
+  /**
+   * Find PRs by branch
+   *
+   * @param branch - Branch name (head or base)
+   * @param repositoryId - Optional repository filter
+   * @returns Array of PRs
+   */
+  async findByBranch(branch, repositoryId) {
+    const prs = await this.list({
+      where: repositoryId ? { repositoryId } : {}
+    });
+    return prs.filter((pr) => pr.headRef === branch || pr.baseRef === branch);
+  }
+  /**
+   * Find PR by number in a repository
+   *
+   * @param repositoryId - Repository ID
+   * @param number - PR number
+   * @returns PullRequest or null
+   */
+  async findByNumber(repositoryId, number) {
+    const results = await this.list({
+      where: { repositoryId, number },
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Find PRs ready to merge (AI-powered)
+   *
+   * @param repositoryId - Optional repository filter
+   * @returns Array of PRs that are ready
+   */
+  async findAIReadyToMerge(repositoryId) {
+    const openPRs = await this.findOpen(repositoryId);
+    const ready = [];
+    for (const pr of openPRs) {
+      if (await pr.isReadyToMerge()) {
+        ready.push(pr);
+      }
+    }
+    return ready;
+  }
+  /**
+   * Get PRs by change size
+   *
+   * @param size - Size classification
+   * @param repositoryId - Optional repository filter
+   * @returns Array of PRs
+   */
+  async findBySize(size, repositoryId) {
+    const prs = await this.findOpen(repositoryId);
+    return prs.filter((pr) => pr.getChangeSize() === size);
+  }
+  /**
+   * Batch sync PRs from repository
+   *
+   * @param repository - Repository to sync from
+   * @param options - Sync options
+   * @returns Array of synced PRs
+   */
+  async batchSync(repository, options = {}) {
+    const prs = await this.findByRepository(repository.id);
+    const synced = [];
+    for (const pr of prs) {
+      await pr.sync(options);
+      synced.push(pr);
+    }
+    return synced;
+  }
+  /**
+   * Find pull requests by tenant ID
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of pull requests for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global pull requests (no tenant)
+   *
+   * @returns Array of global pull requests
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find pull requests for a tenant including global pull requests
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of tenant and global pull requests
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const PullRequests = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PullRequestCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+let Repository = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Repository owner (organization or user)
+   */
+  owner = "";
+  /**
+   * Repository name
+   */
+  name = "";
+  /**
+   * Full name in owner/repo format
+   */
+  fullName = "";
+  /**
+   * Repository description
+   */
+  description = "";
+  /**
+   * Default branch name
+   */
+  defaultBranch = "main";
+  /**
+   * Whether repository is private
+   */
+  isPrivate = false;
+  /**
+   * Repository provider type
+   */
+  providerType = "github";
+  /**
+   * Base URL for self-hosted instances (GitHub Enterprise, GitLab self-hosted, etc.)
+   */
+  baseUrl = "";
+  /**
+   * Environment variable name or config key for token resolution
+   * The token is NOT stored - only the key name is persisted
+   */
+  tokenConfigKey = "GITHUB_TOKEN";
+  /**
+   * Last sync timestamp
+   */
+  lastSyncedAt = null;
+  /**
+   * Transient: Cached repository client (not persisted)
+   */
+  _client;
+  constructor(options = {}) {
+    super(options);
+    if (options.owner !== void 0) this.owner = options.owner;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.fullName !== void 0) this.fullName = options.fullName;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.defaultBranch !== void 0)
+      this.defaultBranch = options.defaultBranch;
+    if (options.isPrivate !== void 0) this.isPrivate = options.isPrivate;
+    if (options.providerType !== void 0)
+      this.providerType = options.providerType;
+    if (options.baseUrl !== void 0) this.baseUrl = options.baseUrl;
+    if (options.tokenConfigKey !== void 0)
+      this.tokenConfigKey = options.tokenConfigKey;
+    if (options.tenantId !== void 0)
+      this.tenantId = options.tenantId;
+  }
+  /**
+   * Get the repository client, resolving token from config
+   *
+   * Token resolution order:
+   * 1. Environment variable matching tokenConfigKey
+   * 2. Module config value matching tokenConfigKey
+   *
+   * @returns Repository client for API operations
+   * @throws Error if token cannot be resolved
+   */
+  async getClient() {
+    if (this._client) {
+      return this._client;
+    }
+    const token = process.env[this.tokenConfigKey] || getModuleConfig("smrt-projects", {})[this.tokenConfigKey];
+    if (!token) {
+      throw new Error(
+        `Token not found for key '${this.tokenConfigKey}'. Set the ${this.tokenConfigKey} environment variable or configure it in smrt.config.`
+      );
+    }
+    this._client = await getRepository({
+      type: this.providerType,
+      owner: this.owner,
+      repo: this.name,
+      token,
+      baseUrl: this.baseUrl || void 0
+    });
+    return this._client;
+  }
+  /**
+   * Clear the cached client (useful after token refresh)
+   */
+  clearClient() {
+    this._client = void 0;
+  }
+  /**
+   * Sync repository metadata from the provider
+   *
+   * @param options - Sync options
+   * @returns This repository with updated fields
+   */
+  async sync(options = {}) {
+    if (!options.force && this.lastSyncedAt && Date.now() - this.lastSyncedAt.getTime() < SYNC_THROTTLE_MS) {
+      return this;
+    }
+    const client = await this.getClient();
+    const repoData = await client.getRepository();
+    this.owner = repoData.owner;
+    this.name = repoData.name;
+    this.fullName = `${repoData.owner}/${repoData.name}`;
+    this.description = repoData.description;
+    this.defaultBranch = repoData.defaultBranch;
+    this.isPrivate = repoData.isPrivate;
+    this.lastSyncedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    return this;
+  }
+  /**
+   * Get issues from this repository
+   *
+   * @param filters - Optional search filters
+   * @returns Array of Issue objects (SMRT models)
+   */
+  async getIssues(filters) {
+    const { IssueCollection: IssueCollection2 } = await Promise.resolve().then(() => Issues);
+    const collection = await IssueCollection2.create(this.options);
+    return await collection.discover({ repository: this, filters });
+  }
+  /**
+   * Get pull requests from this repository
+   *
+   * @param filters - Optional search filters
+   * @returns Array of PullRequest objects (SMRT models)
+   */
+  async getPullRequests(filters) {
+    const { PullRequestCollection: PullRequestCollection2 } = await Promise.resolve().then(() => PullRequests);
+    const collection = await PullRequestCollection2.create(
+      this.options
+    );
+    return await collection.discover({ repository: this, filters });
+  }
+  /**
+   * Create a new issue in this repository
+   *
+   * @param data - Issue creation data
+   * @returns Created Issue (SMRT model)
+   */
+  async createIssue(data) {
+    const repositoryId = this.id ?? void 0;
+    if (!repositoryId) {
+      throw new Error("Repository must be saved before creating issues");
+    }
+    const client = await this.getClient();
+    const created = await client.createIssue(data);
+    const { Issue: Issue2 } = await Promise.resolve().then(() => Issue$1);
+    const issue = new Issue2({
+      ...this.options,
+      repositoryId,
+      number: created.number,
+      nodeId: created.id,
+      title: created.title,
+      body: created.body,
+      state: created.state,
+      author: created.author.login,
+      labels: created.labels.map((l) => l.name),
+      assignees: created.assignees.map((a) => a.login),
+      commentsCount: created.commentsCount,
+      lastSyncedAt: /* @__PURE__ */ new Date()
+    });
+    await issue.save();
+    return issue;
+  }
+  /**
+   * Create a new pull request in this repository
+   *
+   * @param data - PR creation data
+   * @returns Created PullRequest (SMRT model)
+   */
+  async createPullRequest(data) {
+    const repositoryId = this.id ?? void 0;
+    if (!repositoryId) {
+      throw new Error("Repository must be saved before creating pull requests");
+    }
+    const client = await this.getClient();
+    const created = await client.createPullRequest(data);
+    const { PullRequest: PullRequest2 } = await Promise.resolve().then(() => PullRequest$1);
+    const pr = new PullRequest2({
+      ...this.options,
+      repositoryId,
+      number: created.number,
+      nodeId: created.id,
+      title: created.title,
+      body: created.body,
+      state: created.state,
+      author: created.author.login,
+      labels: created.labels.map((l) => l.name),
+      assignees: created.assignees.map((a) => a.login),
+      commentsCount: created.commentsCount,
+      headRef: created.headRef,
+      baseRef: created.baseRef,
+      merged: created.merged,
+      draft: created.draft,
+      lastSyncedAt: /* @__PURE__ */ new Date()
+    });
+    await pr.save();
+    return pr;
+  }
+  /**
+   * Check if this repository has any open issues matching criteria
+   *
+   * @param criteria - Natural language description of what to check
+   * @returns True if matching issues exist
+   */
+  async hasOpenIssuesMatching(criteria) {
+    const issues = await this.getIssues({ state: "open" });
+    if (issues.length === 0) return false;
+    return await this.is(
+      `This repository has open issues matching: ${criteria}. Current open issues: ${issues.map((i) => `#${i.number}: ${i.title}`).join(", ")}`
+    );
+  }
+  /**
+   * Generate a summary of repository activity
+   *
+   * @returns AI-generated summary
+   */
+  async summarizeActivity() {
+    const issues = await this.getIssues({ state: "open", limit: 10 });
+    const prs = await this.getPullRequests({ state: "open", limit: 10 });
+    return await this.do(
+      `Summarize the current activity in this repository. Open issues: ${issues.map((i) => `#${i.number}: ${i.title}`).join(", ")}. Open PRs: ${prs.map((p) => `#${p.number}: ${p.title}`).join(", ")}.`
+    );
+  }
+  /**
+   * Get repository by owner and name
+   *
+   * @param owner - Repository owner
+   * @param name - Repository name
+   * @param options - Additional options
+   * @returns Repository or null if not found
+   */
+  static async getByFullName(owner, name, options = {}) {
+    const { RepositoryCollection: RepositoryCollection2 } = await Promise.resolve().then(() => Repositories);
+    const collection = await RepositoryCollection2.create(options);
+    return await collection.findByFullName(owner, name);
+  }
+};
+__decorateClass$2([
+  tenantId({ nullable: true })
+], Repository.prototype, "tenantId", 2);
+Repository = __decorateClass$2([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "sync"] },
+    // sync is an operator command invoked in-process via the CLI;
+    // it intentionally isn't exposed over HTTP today.
+    cli: { include: ["list", "get", "sync", "create"], skipApiCheck: true }
+  })
+], Repository);
+const logger$1 = createLogger({ level: "info" });
+class RepositoryCollection extends SmrtCollection {
+  static _itemClass = Repository;
+  /**
+   * Find a repository by owner and name
+   *
+   * @param owner - Repository owner
+   * @param name - Repository name
+   * @returns Repository or null
+   */
+  async findByFullName(owner, name) {
+    const results = await this.list({
+      where: { owner, name },
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Find repositories by owner
+   *
+   * @param owner - Repository owner
+   * @returns Array of repositories
+   */
+  async findByOwner(owner) {
+    return await this.list({
+      where: { owner }
+    });
+  }
+  /**
+   * Find repositories by provider type
+   *
+   * @param providerType - Provider type
+   * @returns Array of repositories
+   */
+  async findByProvider(providerType) {
+    return await this.list({
+      where: { providerType }
+    });
+  }
+  /**
+   * Get or create a repository by owner/name
+   *
+   * @param owner - Repository owner
+   * @param name - Repository name
+   * @param options - Additional options for creation
+   * @returns Repository (existing or newly created)
+   */
+  async getOrCreate(owner, name, options = {}) {
+    let repo = await this.findByFullName(owner, name);
+    if (!repo) {
+      repo = await this.create({
+        owner,
+        name,
+        fullName: `${owner}/${name}`,
+        providerType: options.providerType || "github",
+        tokenConfigKey: options.tokenConfigKey || "GITHUB_TOKEN",
+        baseUrl: options.baseUrl || ""
+      });
+      await repo.save();
+    }
+    return repo;
+  }
+  /**
+   * Sync all repositories
+   *
+   * @param options - Sync options
+   * @returns Array of synced repositories
+   */
+  async syncAll(options = {}) {
+    const repos = await this.list({});
+    const synced = [];
+    for (const repo of repos) {
+      await repo.sync(options);
+      synced.push(repo);
+    }
+    return synced;
+  }
+  /**
+   * Find repositories with open issues
+   *
+   * @returns Array of repositories with at least one open issue
+   */
+  async findWithOpenIssues() {
+    const repos = await this.list({});
+    const withIssues = [];
+    for (const repo of repos) {
+      try {
+        const issues = await repo.getIssues({ state: "open", limit: 1 });
+        if (issues.length > 0) {
+          withIssues.push(repo);
+        }
+      } catch (error) {
+        logger$1.warn(
+          `Error accessing issues for repository ${repo.owner}/${repo.name}`,
+          { error: error instanceof Error ? error.message : error }
+        );
+      }
+    }
+    return withIssues;
+  }
+  /**
+   * Find repositories by tenant ID
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of repositories for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global repositories (no tenant)
+   *
+   * @returns Array of global repositories
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find repositories for a tenant including global repositories
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of tenant and global repositories
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Repositories = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RepositoryCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+const logger = createLogger({ level: "info" });
+let Comment = class extends SmrtObject {
+  tenantId = null;
+  issueId;
+  /**
+   * Provider-specific comment ID
+   */
+  commentId = "";
+  /**
+   * Comment body text
+   */
+  body = "";
+  /**
+   * Comment author's login
+   */
+  author = "";
+  /**
+   * When the comment was created
+   */
+  createdAt = null;
+  /**
+   * When the comment was last updated
+   */
+  updatedAt = null;
+  /**
+   * Comment URL
+   */
+  url = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.issueId !== void 0) this.issueId = options.issueId;
+    if (options.commentId !== void 0) this.commentId = options.commentId;
+    if (options.body !== void 0) this.body = options.body;
+    if (options.author !== void 0) this.author = options.author;
+    if (options.createdAt !== void 0) this.createdAt = options.createdAt;
+    if (options.updatedAt !== void 0) this.updatedAt = options.updatedAt;
+    if (options.url !== void 0) this.url = options.url;
+    if (options.tenantId !== void 0)
+      this.tenantId = options.tenantId;
+  }
+  /**
+   * AI-powered: Check if this comment contains a question
+   */
+  async isQuestion() {
+    return await this.is(
+      "This comment contains a question or request for clarification"
+    );
+  }
+  /**
+   * AI-powered: Check if this comment contains approval
+   */
+  async isApproval() {
+    return await this.is(
+      "This comment expresses approval, agreement, or a positive response (LGTM, +1, approved, etc.)"
+    );
+  }
+  /**
+   * AI-powered: Check if this comment requests changes
+   */
+  async requestsChanges() {
+    return await this.is(
+      "This comment requests changes, modifications, or improvements to the issue/PR"
+    );
+  }
+  /**
+   * AI-powered: Extract action items from this comment
+   *
+   * @returns Array of action items
+   */
+  async extractActionItems() {
+    const result = await this.do(
+      `Extract any action items, tasks, or requests from this comment.
+      Return a JSON array of strings, each representing one action item.
+      If no action items, return an empty array [].
+      Only return the JSON array, nothing else.
+
+      Comment: ${this.body}`,
+      // Body is hand-rolled above; skip do()'s object-data injection (no dup).
+      { includeData: false }
+    );
+    try {
+      return JSON.parse(result);
+    } catch (error) {
+      logger.warn("Failed to parse action items JSON", {
+        error: error instanceof Error ? error.message : error,
+        response: result
+      });
+      return [];
+    }
+  }
+  /**
+   * AI-powered: Summarize this comment
+   *
+   * @returns Brief summary
+   */
+  async summarize() {
+    return await this.do(
+      `Summarize this comment in one sentence.
+      Comment by ${this.author}: ${this.body}`,
+      // Author + body hand-rolled above; skip do()'s object-data injection.
+      { includeData: false }
+    );
+  }
+  /**
+   * Get the sentiment of this comment
+   *
+   * @returns Sentiment classification
+   */
+  async getSentiment() {
+    const result = await this.do(
+      `Classify the sentiment of this comment as exactly one of: positive, negative, neutral
+      Only return one word.
+      Comment: ${this.body}`,
+      // Body is hand-rolled above; skip do()'s object-data injection (no dup).
+      { includeData: false }
+    );
+    const normalized = result.toLowerCase().trim();
+    if (normalized.includes("positive")) return "positive";
+    if (normalized.includes("negative")) return "negative";
+    return "neutral";
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], Comment.prototype, "tenantId", 2);
+__decorateClass$1([
+  foreignKey("Issue")
+], Comment.prototype, "issueId", 2);
+Comment = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get"] },
+    mcp: { include: ["list", "get"] },
+    cli: { include: ["list", "get"] }
+  })
+], Comment);
+const Comment$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get Comment() {
+    return Comment;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let Label = class extends SmrtObject {
+  repositoryId;
+  /**
+   * Label name
+   */
+  name = "";
+  /**
+   * Label color (hex without #)
+   */
+  color = "";
+  /**
+   * Label description
+   */
+  description = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.repositoryId !== void 0)
+      this.repositoryId = options.repositoryId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.color !== void 0) this.color = options.color;
+    if (options.description !== void 0)
+      this.description = options.description;
+  }
+  /**
+   * Check if this is a type label (bug, feature, etc.)
+   */
+  isTypeLabel() {
+    const typePatterns = [
+      /^type:/i,
+      /^kind:/i,
+      /^bug$/i,
+      /^feature$/i,
+      /^enhancement$/i,
+      /^docs$/i,
+      /^chore$/i
+    ];
+    return typePatterns.some((p) => p.test(this.name));
+  }
+  /**
+   * Check if this is a priority label
+   */
+  isPriorityLabel() {
+    const priorityPatterns = [
+      /^p[0-4]$/i,
+      /^priority:/i,
+      /^critical$/i,
+      /^high$/i,
+      /^medium$/i,
+      /^low$/i
+    ];
+    return priorityPatterns.some((p) => p.test(this.name));
+  }
+  /**
+   * Check if this is a status label
+   */
+  isStatusLabel() {
+    const statusPatterns = [
+      /^status:/i,
+      /^wip$/i,
+      /^in.?progress$/i,
+      /^blocked$/i,
+      /^needs.?review$/i,
+      /^ready$/i
+    ];
+    return statusPatterns.some((p) => p.test(this.name));
+  }
+  /**
+   * Get the label category
+   *
+   * @returns Category name
+   */
+  getCategory() {
+    if (this.isTypeLabel()) return "type";
+    if (this.isPriorityLabel()) return "priority";
+    if (this.isStatusLabel()) return "status";
+    if (this.name.includes(":")) return "area";
+    return "other";
+  }
+  /**
+   * Parse priority level from label name
+   *
+   * @returns Priority level 0-4 or null
+   */
+  getPriorityLevel() {
+    const match = this.name.match(/p([0-4])/i);
+    if (match) {
+      return parseInt(match[1], 10);
+    }
+    if (/critical/i.test(this.name)) return 0;
+    if (/high/i.test(this.name)) return 1;
+    if (/medium/i.test(this.name)) return 2;
+    if (/low/i.test(this.name)) return 3;
+    return null;
+  }
+  /**
+   * Get label with # prefix for hex color
+   */
+  getHexColor() {
+    return this.color.startsWith("#") ? this.color : `#${this.color}`;
+  }
+  /**
+   * Create a label in the repository
+   */
+  async createInRepository() {
+    if (!this.repositoryId) {
+      throw new Error("Label must have a repositoryId");
+    }
+    const { RepositoryCollection: RepositoryCollection2 } = await Promise.resolve().then(() => Repositories);
+    const collection = await RepositoryCollection2.create(this.options);
+    const repo = await collection.get({ id: this.repositoryId });
+    if (!repo) {
+      throw new Error(`Repository ${this.repositoryId} not found`);
+    }
+    const client = await repo.getClient();
+    await client.createLabel({
+      name: this.name,
+      color: this.color,
+      description: this.description
+    });
+    await this.save();
+  }
+  /**
+   * Update this label in the repository
+   */
+  async updateInRepository() {
+    if (!this.repositoryId) {
+      throw new Error("Label must have a repositoryId");
+    }
+    const { RepositoryCollection: RepositoryCollection2 } = await Promise.resolve().then(() => Repositories);
+    const collection = await RepositoryCollection2.create(this.options);
+    const repo = await collection.get({ id: this.repositoryId });
+    if (!repo) {
+      throw new Error(`Repository ${this.repositoryId} not found`);
+    }
+    const client = await repo.getClient();
+    await client.updateLabel(this.name, {
+      name: this.name,
+      color: this.color,
+      description: this.description
+    });
+    await this.save();
+  }
+};
+__decorateClass([
+  foreignKey("Repository")
+], Label.prototype, "repositoryId", 2);
+Label = __decorateClass([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: { include: ["list", "get", "create", "update", "delete"] }
+  })
+], Label);
+export {
+  Comment,
+  Issue,
+  IssueCollection,
+  Label,
+  PROJECTS_MODULE_META,
+  PROJECTS_UI_SLOTS,
+  Project,
+  ProjectCollection,
+  PullRequest,
+  PullRequestCollection,
+  Repository,
+  RepositoryCollection,
+  issueIncorporateFeedbackPrompt
+};
+//# sourceMappingURL=index.js.map