evrex-mcp 0.4.0 → 0.6.0

package/dist/tickets.js

@@ -0,0 +1,636 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  evrexApi: () => evrexApi
+});
+function headers() {
+  const base = { "Content-Type": "application/json" };
+  if (EVREX_TOKEN) base.Authorization = `Bearer ${EVREX_TOKEN}`;
+  return base;
+}
+function describeFailure(method, path, status, statusText) {
+  if (status === 401 || status === 403) {
+    return EVREX_TOKEN ? `${method} ${path} -> ${status}: the EVREX_TOKEN this server was started with was rejected. It may be revoked or expired.` : `${method} ${path} -> ${status}: this evrex backend requires a credential, but no EVREX_TOKEN is set for this MCP server.`;
+  }
+  return `${method} ${path} -> ${status} ${statusText}`;
+}
+async function request(method, path, { body, absentIsAnswer } = {}) {
+  const res = await fetch(`${API_BASE_URL}${path}`, {
+    method,
+    headers: headers(),
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+  if (res.status === 404 && absentIsAnswer) return null;
+  if (!res.ok) throw new Error(describeFailure(method, path, res.status, res.statusText));
+  return await res.json();
+}
+var DEFAULT_API_BASE_URL, API_BASE_URL, EVREX_TOKEN, get, getOrNull, post, evrexApi;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    DEFAULT_API_BASE_URL = "https://api.evrex.ai";
+    API_BASE_URL = (process.env.EVREX_API_BASE_URL ?? process.env.EVREX_API_URL ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+    EVREX_TOKEN = process.env.EVREX_TOKEN ?? process.env.EVREX_API_TOKEN ?? null;
+    get = (path) => request("GET", path);
+    getOrNull = (path) => request("GET", path, { absentIsAnswer: true });
+    post = (path, body) => request("POST", path, { body });
+    evrexApi = {
+      baseUrl: API_BASE_URL,
+      repos: () => get("/repos"),
+      commits: (repoPath) => get(`/commits?repoPath=${encodeURIComponent(repoPath)}`),
+      // Abbreviated shas resolve server-side, so a value pasted from `git log`
+      // works here (apps/backend/src/reads/reads.service.ts#resolveSha).
+      commit: (sha) => getOrNull(`/commits/${encodeURIComponent(sha)}`),
+      sessions: (repoPath) => get(`/sessions?repoPath=${encodeURIComponent(repoPath)}`),
+      session: (id) => getOrNull(`/sessions/${encodeURIComponent(id)}`),
+      ask: (repoPath, text, filePaths) => post("/ask", { repoPath, text, filePaths }),
+      // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
+      // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
+      // which wants ranked hits fast, not a synthesized paragraph.
+      search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths })
+    };
+  }
+});
+
+// src/credential-store.ts
+var credential_store_exports = {};
+__export(credential_store_exports, {
+  CredentialStore: () => CredentialStore,
+  NoKeychainError: () => NoKeychainError,
+  systemRunner: () => systemRunner
+});
+import { spawn } from "node:child_process";
+var SERVICE, ACCOUNT, systemRunner, NoKeychainError, CredentialStore, WINDOWS_PATH, WINDOWS_STORE, WINDOWS_RETRIEVE, WINDOWS_REMOVE;
+var init_credential_store = __esm({
+  "src/credential-store.ts"() {
+    "use strict";
+    SERVICE = "evrex-capture";
+    ACCOUNT = "evrex";
+    systemRunner = {
+      platform: process.platform,
+      run(command, args, stdin) {
+        return new Promise((resolve) => {
+          const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+          let stdout = "";
+          let stderr = "";
+          child.stdout.on("data", (d) => stdout += d.toString());
+          child.stderr.on("data", (d) => stderr += d.toString());
+          child.on("error", () => resolve({ code: 127, stdout: "", stderr: "" }));
+          child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+          if (stdin !== void 0) child.stdin.write(stdin);
+          child.stdin.end();
+        });
+      }
+    };
+    NoKeychainError = class extends Error {
+      constructor(platform) {
+        super(
+          `evrex could not find a credential store on this machine (${platform}).
+  macOS   needs \`security\`, which ships with the system.
+  Linux   needs \`secret-tool\` \u2014 install libsecret-tools (Debian/Ubuntu)
+          or libsecret (Fedora/Arch), and make sure a keyring daemon is running.
+  Windows needs PowerShell.
+evrex will not fall back to writing the credential in a plain file.`
+        );
+        this.name = "NoKeychainError";
+      }
+    };
+    CredentialStore = class {
+      constructor(runner = systemRunner) {
+        this.runner = runner;
+      }
+      async available() {
+        switch (this.runner.platform) {
+          case "darwin":
+            return (await this.runner.run("security", ["help"])).code !== 127;
+          case "win32":
+            return (await this.runner.run("powershell", ["-Command", "$PSVersionTable.PSVersion.Major"])).code !== 127;
+          default:
+            return (await this.runner.run("secret-tool", ["--version"])).code !== 127;
+        }
+      }
+      /**
+       * Replaces any existing credential rather than adding a second one. A
+       * machine that re-enrols after expiry must end up with exactly one entry, or
+       * the next read is a coin flip between the live credential and a dead one.
+       */
+      async store(secret) {
+        if (!await this.available()) throw new NoKeychainError(this.runner.platform);
+        switch (this.runner.platform) {
+          case "darwin": {
+            const result = await this.runner.run(
+              "security",
+              ["add-generic-password", "-a", ACCOUNT, "-s", SERVICE, "-U", "-w"],
+              `${secret}
+${secret}
+`
+            );
+            if (result.code !== 0) throw new Error(`Keychain write failed: ${result.stderr.trim()}`);
+            return;
+          }
+          case "win32": {
+            const result = await this.runner.run(
+              "powershell",
+              ["-NoProfile", "-Command", WINDOWS_STORE],
+              secret
+            );
+            if (result.code !== 0) throw new Error(`DPAPI write failed: ${result.stderr.trim()}`);
+            return;
+          }
+          default: {
+            const result = await this.runner.run(
+              "secret-tool",
+              ["store", "--label=evrex capture credential", "service", SERVICE, "account", ACCOUNT],
+              secret
+            );
+            if (result.code !== 0) throw new Error(`secret-tool write failed: ${result.stderr.trim()}`);
+            return;
+          }
+        }
+      }
+      /** Null when there is nothing stored, which is the normal pre-enrolment state. */
+      async retrieve() {
+        if (!await this.available()) throw new NoKeychainError(this.runner.platform);
+        switch (this.runner.platform) {
+          case "darwin": {
+            const r = await this.runner.run("security", [
+              "find-generic-password",
+              "-a",
+              ACCOUNT,
+              "-s",
+              SERVICE,
+              "-w"
+            ]);
+            return r.code === 0 ? r.stdout.trim() || null : null;
+          }
+          case "win32": {
+            const r = await this.runner.run("powershell", ["-NoProfile", "-Command", WINDOWS_RETRIEVE]);
+            return r.code === 0 ? r.stdout.trim() || null : null;
+          }
+          default: {
+            const r = await this.runner.run("secret-tool", [
+              "lookup",
+              "service",
+              SERVICE,
+              "account",
+              ACCOUNT
+            ]);
+            return r.code === 0 ? r.stdout.trim() || null : null;
+          }
+        }
+      }
+      /** Idempotent: removing a credential that is not there is not an error. */
+      async remove() {
+        if (!await this.available()) return;
+        switch (this.runner.platform) {
+          case "darwin":
+            await this.runner.run("security", [
+              "delete-generic-password",
+              "-a",
+              ACCOUNT,
+              "-s",
+              SERVICE
+            ]);
+            return;
+          case "win32":
+            await this.runner.run("powershell", ["-NoProfile", "-Command", WINDOWS_REMOVE]);
+            return;
+          default:
+            await this.runner.run("secret-tool", [
+              "clear",
+              "service",
+              SERVICE,
+              "account",
+              ACCOUNT
+            ]);
+            return;
+        }
+      }
+    };
+    WINDOWS_PATH = "$env:APPDATA\\evrex\\capture.cred";
+    WINDOWS_STORE = `
+$ErrorActionPreference = 'Stop'
+$p = "${WINDOWS_PATH}"
+New-Item -ItemType Directory -Force -Path (Split-Path $p) | Out-Null
+$secret = [Console]::In.ReadToEnd().Trim()
+ConvertTo-SecureString $secret -AsPlainText -Force | ConvertFrom-SecureString | Set-Content -Path $p
+`.trim();
+    WINDOWS_RETRIEVE = `
+$ErrorActionPreference = 'Stop'
+$p = "${WINDOWS_PATH}"
+if (-not (Test-Path $p)) { exit 1 }
+$sec = Get-Content $p | ConvertTo-SecureString
+[Runtime.InteropServices.Marshal]::PtrToStringAuto(
+  [Runtime.InteropServices.Marshal]::SecureStringToBSTR($sec))
+`.trim();
+    WINDOWS_REMOVE = `
+$p = "${WINDOWS_PATH}"
+if (Test-Path $p) { Remove-Item $p -Force }
+`.trim();
+  }
+});
+
+// src/tickets.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+// ../../packages/ingest-core/src/types.ts
+var CONVERSATION_KINDS = [
+  "claude-code",
+  "cursor",
+  "codex",
+  "gemini",
+  "slack"
+];
+var REFERENCE_KINDS = ["linear", "jira", "confluence"];
+var SOURCE_KINDS = [
+  ...CONVERSATION_KINDS,
+  ...REFERENCE_KINDS
+];
+
+// ../../packages/ingest-core/src/sanitize.ts
+var NUL = String.fromCharCode(0);
+
+// ../../packages/ingest-core/src/linear.ts
+var LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
+var PRIORITY = {
+  0: "No priority",
+  1: "Urgent",
+  2: "High",
+  3: "Medium",
+  4: "Low"
+};
+var STATE_TYPE = {
+  triage: "triage",
+  backlog: "backlog",
+  unstarted: "todo",
+  started: "in-progress",
+  completed: "done",
+  canceled: "cancelled"
+};
+var LINEAR_ISSUES_QUERY = `
+  query EvrexIssues($first: Int!, $after: String) {
+    issues(first: $first, after: $after, orderBy: updatedAt) {
+      nodes {
+        identifier
+        title
+        url
+        priority
+        createdAt
+        updatedAt
+        state { name type }
+        assignee { id displayName }
+        team { key name }
+        project { name }
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function linearIssueToTicket(issue) {
+  if (!issue.identifier) return null;
+  const attributes = {
+    title: issue.title ?? issue.identifier,
+    status: issue.state?.name ?? null,
+    statusCategory: issue.state?.type ? STATE_TYPE[issue.state.type] ?? null : null,
+    assignee: issue.assignee?.displayName ?? null,
+    assigneeId: issue.assignee?.id ?? null,
+    team: issue.team?.key ?? null,
+    project: issue.project?.name ?? null,
+    // Linear has one kind of issue; the field exists so a Jira row and a
+    // Linear row are the same shape, which is what U5 exists to prove.
+    issueType: null,
+    // Null rather than "No priority" when the field is absent: unset and
+    // explicitly-not-prioritised are different claims.
+    priority: typeof issue.priority === "number" ? PRIORITY[issue.priority] ?? null : null,
+    // Linear records completion as a state, not as a separate resolution.
+    resolution: null
+  };
+  return {
+    externalId: issue.identifier,
+    kind: "linear",
+    url: issue.url ?? `https://linear.app/issue/${issue.identifier}`,
+    createdAt: issue.createdAt ?? null,
+    updatedAt: issue.updatedAt ?? null,
+    attributes
+  };
+}
+function linearAuthHeader(auth) {
+  if (auth.accessToken) return `Bearer ${auth.accessToken}`;
+  if (auth.apiKey) return auth.apiKey;
+  throw new Error(
+    "Linear needs either an API key or an OAuth access token; got neither."
+  );
+}
+async function fetchLinearIssues(options) {
+  const call = options.fetch ?? globalThis.fetch;
+  const pageSize = options.pageSize ?? 50;
+  const limit = options.limit ?? Infinity;
+  const tickets = [];
+  let after = null;
+  while (tickets.length < limit) {
+    const response = await call(LINEAR_GRAPHQL_URL, {
+      method: "POST",
+      headers: {
+        Authorization: linearAuthHeader(options.auth),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: LINEAR_ISSUES_QUERY,
+        variables: {
+          first: Math.min(pageSize, limit - tickets.length),
+          after
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Linear returned ${response.status} ${response.statusText}`
+      );
+    }
+    const body = await response.json();
+    if (body.errors?.length) {
+      throw new Error(
+        `Linear rejected the query: ${body.errors.map((e) => e.message).join("; ")}`
+      );
+    }
+    const page = body.data?.issues;
+    for (const node of page?.nodes ?? []) {
+      const ticket = linearIssueToTicket(node);
+      if (ticket) tickets.push(ticket);
+    }
+    if (!page?.pageInfo?.hasNextPage || !page.pageInfo.endCursor) break;
+    after = page.pageInfo.endCursor;
+  }
+  return tickets;
+}
+
+// ../../packages/ingest-core/src/jira.ts
+var JIRA_SEARCH_PATH = "/rest/api/3/search/jql";
+var JIRA_FIELDS = [
+  "summary",
+  "status",
+  "assignee",
+  "resolution",
+  "created",
+  "updated",
+  "project",
+  "issuetype",
+  "priority"
+];
+var STATUS_CATEGORY = {
+  new: "todo",
+  indeterminate: "in-progress",
+  done: "done"
+};
+function jiraIssueToTicket(issue, siteUrl) {
+  if (!issue.key) return null;
+  const f = issue.fields ?? {};
+  const attributes = {
+    title: f.summary ?? issue.key,
+    status: f.status?.name ?? null,
+    statusCategory: f.status?.statusCategory?.key ? STATUS_CATEGORY[f.status.statusCategory.key] ?? null : null,
+    // Null when the assignee's privacy settings withhold it, which is not the
+    // same claim as an unassigned ticket — `assigneeId` distinguishes them.
+    assignee: f.assignee?.displayName ?? null,
+    assigneeId: f.assignee?.accountId ?? null,
+    // Jira has no team on an issue; the project is the closest equivalent and
+    // is reported as itself rather than smuggled into `team`.
+    team: null,
+    project: f.project?.key ?? null,
+    issueType: f.issuetype?.name ?? null,
+    priority: f.priority?.name ?? null,
+    resolution: f.resolution?.name ?? null
+  };
+  return {
+    externalId: issue.key,
+    kind: "jira",
+    url: `${siteUrl.replace(/\/+$/, "")}/browse/${issue.key}`,
+    createdAt: f.created ?? null,
+    updatedAt: f.updated ?? null,
+    attributes
+  };
+}
+function jiraBasicAuth(email, apiToken) {
+  return `Basic ${Buffer.from(`${email}:${apiToken}`).toString("base64")}`;
+}
+async function fetchJiraIssues(options) {
+  const call = options.fetch ?? globalThis.fetch;
+  const site = options.siteUrl.replace(/\/+$/, "");
+  const pageSize = options.pageSize ?? 100;
+  const limit = options.limit ?? Infinity;
+  const jql = options.jql ?? "ORDER BY updated DESC";
+  const tickets = [];
+  let nextPageToken = null;
+  while (tickets.length < limit) {
+    const response = await call(`${site}${JIRA_SEARCH_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: jiraBasicAuth(options.email, options.apiToken),
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        jql,
+        fields: [...JIRA_FIELDS],
+        maxResults: Math.min(pageSize, limit - tickets.length),
+        ...nextPageToken ? { nextPageToken } : {}
+      })
+    });
+    if (!response.ok) {
+      const hint = response.status === 410 ? ` \u2014 that is what the removed /rest/api/3/search returns; this client uses ${JIRA_SEARCH_PATH}` : "";
+      throw new Error(
+        `Jira returned ${response.status} ${response.statusText}${hint}`
+      );
+    }
+    const body = await response.json();
+    for (const issue of body.issues ?? []) {
+      const ticket = jiraIssueToTicket(issue, site);
+      if (ticket) tickets.push(ticket);
+    }
+    if (!body.nextPageToken) break;
+    nextPageToken = body.nextPageToken;
+  }
+  return tickets;
+}
+
+// src/batch.ts
+var MAX_BATCH_BYTES = 24 * 1024 * 1024;
+function measure(items) {
+  return items.map((item) => ({
+    item,
+    bytes: Buffer.byteLength(JSON.stringify(item), "utf8")
+  }));
+}
+function batchByBytes(items, maxBytes = MAX_BATCH_BYTES) {
+  const batches = [];
+  let current = [];
+  let size = 0;
+  for (const { item, bytes } of measure(items)) {
+    if (current.length > 0 && size + bytes > maxBytes) {
+      batches.push(current);
+      current = [];
+      size = 0;
+    }
+    current.push(item);
+    size += bytes;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+
+// src/tickets.ts
+var CONNECTORS = [
+  {
+    kind: "linear",
+    requires: ["EVREX_LINEAR_API_KEY", "EVREX_LINEAR_WORKSPACE"],
+    workspace: (env) => env.EVREX_LINEAR_WORKSPACE,
+    hint: "Set EVREX_LINEAR_API_KEY to a Linear API key (Settings -> Security & access -> Personal API keys) and EVREX_LINEAR_WORKSPACE to your workspace's URL key.",
+    collect: (env, deps) => (deps.fetchLinear ?? fetchLinearIssues)({
+      auth: { apiKey: env.EVREX_LINEAR_API_KEY },
+      limit: numeric(env.EVREX_TICKET_LIMIT)
+    })
+  },
+  {
+    kind: "jira",
+    requires: ["EVREX_JIRA_SITE", "EVREX_JIRA_EMAIL", "EVREX_JIRA_API_TOKEN"],
+    // The site host, which is what makes PROJ-1 on two Jira sites two tickets.
+    workspace: (env) => env.EVREX_JIRA_SITE.replace(/^https?:\/\//, "").replace(/\/+$/, ""),
+    hint: "Set EVREX_JIRA_SITE (https://acme.atlassian.net), EVREX_JIRA_EMAIL to your Atlassian account email, and EVREX_JIRA_API_TOKEN to a token from id.atlassian.com/manage-profile/security/api-tokens.",
+    collect: (env, deps) => (deps.fetchJira ?? fetchJiraIssues)({
+      siteUrl: env.EVREX_JIRA_SITE,
+      email: env.EVREX_JIRA_EMAIL,
+      apiToken: env.EVREX_JIRA_API_TOKEN,
+      jql: env.EVREX_JIRA_JQL,
+      limit: numeric(env.EVREX_TICKET_LIMIT)
+    })
+  }
+];
+function numeric(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+async function syncTickets(deps) {
+  const result = {
+    delivered: {},
+    configured: [],
+    failed: false
+  };
+  for (const connector of CONNECTORS) {
+    const present = connector.requires.filter((key) => deps.env[key]);
+    if (present.length === 0) continue;
+    if (present.length < connector.requires.length) {
+      const missing = connector.requires.filter((key) => !deps.env[key]);
+      deps.log(
+        `  ${connector.kind}: half-configured, missing ${missing.join(", ")}.
+    ${connector.hint}`
+      );
+      result.failed = true;
+      continue;
+    }
+    result.configured.push(connector.kind);
+    const workspace = connector.workspace(deps.env);
+    let tickets;
+    try {
+      tickets = await connector.collect(deps.env, deps);
+    } catch (error) {
+      deps.log(`  ${connector.kind}: ${error.message}`);
+      result.failed = true;
+      continue;
+    }
+    let sent = 0;
+    for (const batch of batchByBytes(tickets)) {
+      const ok = await deps.post("/ingest/tickets", {
+        kind: connector.kind,
+        workspace,
+        tickets: batch.map((t) => ({
+          externalId: t.externalId,
+          url: t.url,
+          createdAt: t.createdAt,
+          updatedAt: t.updatedAt,
+          attributes: t.attributes
+        }))
+      });
+      if (!ok) {
+        result.failed = true;
+        break;
+      }
+      sent += batch.length;
+      deps.log(`  ${connector.kind}  ${sent}/${tickets.length}`);
+    }
+    result.delivered[connector.kind] = sent;
+  }
+  if (result.configured.length === 0 && !result.failed) {
+    deps.log(
+      "No ticket connector is configured. Set one of:\n" + CONNECTORS.map((c) => `  ${c.kind}: ${c.requires.join(", ")}`).join("\n")
+    );
+  }
+  return result;
+}
+async function main() {
+  const { evrexApi: evrexApi2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const { CredentialStore: CredentialStore2 } = await Promise.resolve().then(() => (init_credential_store(), credential_store_exports));
+  const token = process.env.EVREX_TOKEN ?? await new CredentialStore2().retrieve().catch(() => null);
+  if (!token) {
+    console.error(
+      "evrex: this machine is not enrolled.\n  Run `npx -y evrex-mcp enrol` first, or set EVREX_TOKEN."
+    );
+    process.exit(1);
+  }
+  const result = await syncTickets({
+    env: process.env,
+    log: (line) => console.error(line),
+    post: async (path, body) => {
+      try {
+        const res = await fetch(`${evrexApi2.baseUrl}${path}`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) console.error(`  ${path} -> ${res.status}`);
+        return res.ok;
+      } catch (error) {
+        console.error(`  ${path} -> ${error.message}`);
+        return false;
+      }
+    }
+  });
+  const total = Object.values(result.delivered).reduce((n, d) => n + d, 0);
+  if (result.configured.length > 0) {
+    console.error(`
+  ${total} tickets from ${result.configured.join(", ")}`);
+  }
+  process.exit(result.failed ? 1 : 0);
+}
+function isMain() {
+  const invoked = process.argv[1];
+  if (!invoked) return false;
+  try {
+    return realpathSync(invoked) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+if (isMain()) {
+  main().catch((error) => {
+    console.error("evrex tickets failed:", error);
+    process.exit(1);
+  });
+}
+export {
+  syncTickets
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evrex-mcp",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "MCP server that gives coding agents the recorded reasoning behind a repo: prior decisions, hard constraints, and approaches already rejected.",
   "keywords": [
     "mcp",
@@ -13,10 +13,18 @@
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
-    "evrex-mcp": "dist/index.js"
+    "evrex-mcp": "dist/index.js",
+    "evrex-hook": "dist/hook.js",
+    "evrex-capture": "dist/capture.js",
+    "evrex-import": "dist/import.js",
+    "evrex-tickets": "dist/tickets.js"
   },
   "files": [
     "dist/index.js",
+    "dist/hook.js",
+    "dist/capture.js",
+    "dist/import.js",
+    "dist/tickets.js",
     "README.md"
   ],
   "engines": {
@@ -38,6 +46,7 @@
   },
   "devDependencies": {
     "@repo/eslint-config": "workspace:*",
+    "@repo/ingest-core": "workspace:*",
     "@repo/llm-core": "workspace:*",
     "@repo/typescript-config": "workspace:*",
     "@types/node": "^24.0.0",