jowork 0.2.4 → 0.3.0

package/dist/chunk-EYP6WMFF.js

@@ -0,0 +1,153 @@
+import {
+  bareReposDir
+} from "./chunk-4PIT2GZ4.js";
+import {
+  logError,
+  logInfo
+} from "./chunk-MYDK7MWB.js";
+
+// src/sync/git-manager.ts
+import simpleGit from "simple-git";
+import { existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join, basename } from "path";
+var GitManager = class _GitManager {
+  git;
+  repoDir;
+  constructor(repoDir) {
+    this.repoDir = repoDir;
+    this.git = simpleGit(repoDir);
+  }
+  /** Initialize git repo if not already initialized */
+  async init() {
+    const gitDir = join(this.repoDir, ".git");
+    if (existsSync(gitDir)) return;
+    await this.git.init();
+    const gitignore = [
+      "# JoWork \u2014 auto-generated",
+      "*.db",
+      "*.db-wal",
+      "*.db-shm",
+      ".DS_Store",
+      "Thumbs.db",
+      "*.key",
+      "*.pem",
+      "*.env",
+      "credentials/",
+      ""
+    ].join("\n");
+    writeFileSync(join(this.repoDir, ".gitignore"), gitignore);
+    await this.git.add("-A");
+    await this.git.commit("init: jowork data repo");
+    logInfo("git", "Initialized data repo");
+  }
+  /** Commit all changes after a sync cycle */
+  async commitSync(summary) {
+    await this.git.add("-A");
+    const status = await this.git.status();
+    if (status.staged.length === 0 && status.created.length === 0 && status.modified.length === 0 && status.deleted.length === 0) {
+      return null;
+    }
+    const lines = [`sync: ${summary.timestamp}`, ""];
+    for (const s of summary.sources) {
+      if (s.newObjects > 0) {
+        lines.push(`${s.source}: +${s.newObjects} ${s.label ?? "objects"}`);
+      }
+    }
+    if (lines.length === 2) lines.push("(no new data)");
+    const result = await this.git.commit(lines.join("\n"));
+    const sha = result.commit;
+    logInfo("git", `Committed sync: ${sha}`, {
+      files: status.staged.length + status.created.length
+    });
+    return sha;
+  }
+  /** Get recent sync log entries */
+  async getLog(limit = 20) {
+    const log = await this.git.log({ maxCount: limit });
+    return log.all.map((entry) => ({
+      hash: entry.hash.slice(0, 7),
+      date: entry.date,
+      message: entry.message.split("\n")[0]
+    }));
+  }
+  /** Get current status (changed files) */
+  async getStatus() {
+    const status = await this.git.status();
+    return {
+      modified: status.modified,
+      created: status.created,
+      deleted: status.deleted
+    };
+  }
+  // ── Bare repo clone/fetch (GitHub/GitLab code repos) ───────────────
+  /**
+   * Clone a repo as bare (no working tree, minimal disk usage).
+   * Uses --filter=blob:limit=1m to skip large binary blobs.
+   * Returns the local bare repo path, or null on failure.
+   */
+  static async cloneBare(repoUrl, source, repoName, token) {
+    const dir = join(bareReposDir(), source, `${repoName}.git`);
+    if (existsSync(dir)) {
+      return _GitManager.fetchBare(dir);
+    }
+    mkdirSync(join(bareReposDir(), source), { recursive: true });
+    let cloneUrl = repoUrl;
+    if (token && repoUrl.startsWith("https://")) {
+      const url = new URL(repoUrl);
+      url.username = source === "gitlab" ? "oauth2" : "x-access-token";
+      url.password = token;
+      cloneUrl = url.toString();
+    }
+    try {
+      const git = simpleGit();
+      await git.clone(cloneUrl, dir, [
+        "--bare",
+        "--filter=blob:limit=1m",
+        "--single-branch"
+      ]);
+      logInfo("git", `Cloned bare: ${source}/${repoName}`);
+      return dir;
+    } catch (err) {
+      logError("git", `Failed to clone ${source}/${repoName}: ${err}`);
+      return null;
+    }
+  }
+  /** Fetch updates for an existing bare repo. Returns path or null on failure. */
+  static async fetchBare(bareDir) {
+    try {
+      const git = simpleGit(bareDir);
+      await git.fetch(["--prune"]);
+      return bareDir;
+    } catch (err) {
+      logError("git", `Failed to fetch ${bareDir}: ${err}`);
+      return null;
+    }
+  }
+  /**
+   * Clone or fetch multiple repos in parallel.
+   * Returns results: { repo, path, error? } for each.
+   */
+  static async syncBareRepos(repos) {
+    const results = await Promise.allSettled(
+      repos.map(async (repo) => {
+        const dir = join(bareReposDir(), repo.source, `${repo.name}.git`);
+        const isNew = !existsSync(dir);
+        const path = await _GitManager.cloneBare(repo.url, repo.source, repo.name, repo.token);
+        return { name: repo.name, path, isNew };
+      })
+    );
+    return results.map(
+      (r) => r.status === "fulfilled" ? r.value : { name: "unknown", path: null, isNew: false }
+    );
+  }
+  /** List all bare repos for a source. */
+  static listBareRepos(source) {
+    const dir = join(bareReposDir(), source);
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".git")).map((f) => basename(f, ".git"));
+  }
+};
+
+export {
+  GitManager
+};

package/dist/{chunk-JSTXMDXI.js → chunk-FCFZCZHR.js}

@@ -1,7 +1,7 @@
 import {
   configPath,
   joworkDir
-} from "./chunk-ROIINI33.js";
+} from "./chunk-4PIT2GZ4.js";
 
 // src/utils/config.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";

package/dist/chunk-FX6Z3QHV.js

@@ -0,0 +1,34 @@
+import {
+  fileRepoDir
+} from "./chunk-4PIT2GZ4.js";
+
+// src/utils/content-reader.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function readObjectContent(_sqlite, _objectId, filePath) {
+  if (!filePath) return null;
+  try {
+    return readFileSync(join(fileRepoDir(), filePath), "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readObjectContents(_sqlite, objects) {
+  const result = /* @__PURE__ */ new Map();
+  const repoDir = fileRepoDir();
+  for (const obj of objects) {
+    if (obj.filePath) {
+      try {
+        const content = readFileSync(join(repoDir, obj.filePath), "utf-8");
+        result.set(obj.id, content);
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+
+export {
+  readObjectContent,
+  readObjectContents
+};

package/dist/chunk-HENAABEL.js

@@ -0,0 +1,419 @@
+import {
+  readObjectContent
+} from "./chunk-FX6Z3QHV.js";
+import {
+  formatIssue,
+  formatPullRequest
+} from "./chunk-RO3KK5RC.js";
+import {
+  logError,
+  logInfo
+} from "./chunk-MYDK7MWB.js";
+
+// src/sync/linker.ts
+var PATTERNS = [
+  // GitHub/GitLab PR/Issue references
+  { type: "pr", regex: /(?:PR|pr|Pull Request|pull request)\s*#?(\d+)/g, confidence: "high" },
+  { type: "issue", regex: /(?:issue|Issue|ISSUE)\s*#?(\d+)/g, confidence: "high" },
+  { type: "issue", regex: /#(\d{2,6})\b/g, confidence: "medium" },
+  // bare #123
+  // Linear-style issue keys (e.g. LIN-234, PROJ-56)
+  // Requires 2+ digit number to reduce false positives (GPT-5, GLP-1 are NOT issues)
+  { type: "issue", regex: /\b([A-Z]{2,10}-\d{2,6})\b/g, confidence: "high" },
+  // Git commit SHA
+  { type: "commit", regex: /\b([0-9a-f]{7,40})\b/g, confidence: "low" },
+  // URLs
+  { type: "url", regex: /https?:\/\/[^\s<>"{}|\\^`\[\]]+/g, confidence: "high" },
+  // @mentions (feishu user_id format)
+  { type: "mention", regex: /@([a-zA-Z0-9_]+)/g, confidence: "medium" },
+  // Action items (Chinese + English)
+  { type: "action_item", regex: /(?:需要|TODO|FIXME|待办|截止|deadline|action item|任务)[：:\s]+([^\n。.]{5,80})/gi, confidence: "medium" }
+];
+function extractLinks(content) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of PATTERNS) {
+    if (pattern.type === "commit" && content.length < 100) continue;
+    const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const identifier = match[1] ?? match[0];
+      const key = `${pattern.type}:${identifier}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (identifier.length < 3 && pattern.type !== "pr") continue;
+      if (pattern.type === "commit" && identifier.length < 7) continue;
+      let metadata;
+      if (pattern.type === "action_item") {
+        const surroundingText = content.slice(
+          Math.max(0, (match.index ?? 0) - 50),
+          Math.min(content.length, (match.index ?? 0) + match[0].length + 50)
+        );
+        const mentionMatch = surroundingText.match(/@([a-zA-Z0-9_]+)/);
+        const dateMatch = surroundingText.match(
+          /(\d{4}[-/]\d{1,2}[-/]\d{1,2}|\d{1,2}月\d{1,2}[日号]|\d{1,2}\/\d{1,2})/
+        );
+        if (mentionMatch || dateMatch) {
+          metadata = {};
+          if (mentionMatch) metadata.assignee = mentionMatch[1];
+          if (dateMatch) metadata.dueDate = dateMatch[1];
+        }
+      }
+      links.push({
+        linkType: pattern.type,
+        identifier,
+        confidence: pattern.confidence,
+        ...metadata ? { metadata } : {}
+      });
+    }
+  }
+  return links;
+}
+function processObjectLinks(sqlite, objectId, content) {
+  const links = extractLinks(content);
+  if (links.length === 0) return 0;
+  const insert = sqlite.prepare(`
+    INSERT OR IGNORE INTO object_links (id, source_object_id, target_object_id, link_type, identifier, metadata, confidence, created_at)
+    VALUES (?, ?, NULL, ?, ?, ?, ?, ?)
+  `);
+  const now = Date.now();
+  let count = 0;
+  const batch = sqlite.transaction(() => {
+    for (const link of links) {
+      const id = `${objectId}:${link.linkType}:${link.identifier}`.slice(0, 64);
+      insert.run(
+        id,
+        objectId,
+        link.linkType,
+        link.identifier,
+        link.metadata ? JSON.stringify(link.metadata) : null,
+        link.confidence,
+        now
+      );
+      count++;
+    }
+  });
+  batch();
+  return count;
+}
+function linkAllUnprocessed(sqlite) {
+  const unprocessed = sqlite.prepare(`
+    SELECT o.id, o.file_path FROM objects o
+    WHERE o.links_processed = 0
+    LIMIT 1000
+  `).all();
+  if (unprocessed.length === 0) return { processed: 0, linksCreated: 0 };
+  let linksCreated = 0;
+  const markProcessed = sqlite.prepare("UPDATE objects SET links_processed = 1 WHERE id = ?");
+  const batch = sqlite.transaction(() => {
+    for (const obj of unprocessed) {
+      const content = readObjectContent(sqlite, obj.id, obj.file_path);
+      if (!content) {
+        markProcessed.run(obj.id);
+        continue;
+      }
+      linksCreated += processObjectLinks(sqlite, obj.id, content);
+      markProcessed.run(obj.id);
+    }
+  });
+  batch();
+  logInfo("linker", `Processed ${unprocessed.length} objects, created ${linksCreated} links`);
+  return { processed: unprocessed.length, linksCreated };
+}
+
+// src/sync/gitlab.ts
+var defaultLogger = {
+  info: (msg, ctx) => logInfo("sync", msg, ctx),
+  warn: (msg, ctx) => logError("sync", msg, ctx),
+  error: (msg, ctx) => logError("sync", msg, ctx)
+};
+var RATE_LIMIT_DELAY_MS = 200;
+async function fetchAllPages(url, headers, logger) {
+  const results = [];
+  let nextUrl = url;
+  while (nextUrl) {
+    const res = await fetch(nextUrl, { headers });
+    if (!res.ok) {
+      if (res.status === 429) {
+        const retryAfter = res.headers.get("retry-after");
+        const waitMs = retryAfter ? parseInt(retryAfter) * 1e3 : 5e3;
+        logger.warn(`Rate limited, waiting ${Math.ceil(waitMs / 1e3)}s`);
+        await new Promise((r) => setTimeout(r, waitMs));
+        continue;
+      }
+      break;
+    }
+    const data = await res.json();
+    results.push(...data);
+    const nextPage = res.headers.get("x-next-page");
+    if (nextPage && nextPage !== "") {
+      const currentUrl = nextUrl;
+      const parsed = new URL(currentUrl);
+      parsed.searchParams.set("page", nextPage);
+      nextUrl = parsed.toString();
+    } else {
+      nextUrl = null;
+    }
+    if (nextUrl) {
+      await new Promise((r) => setTimeout(r, RATE_LIMIT_DELAY_MS));
+    }
+  }
+  return results;
+}
+async function syncGitLab(ctx, data, logger = defaultLogger) {
+  const token = data.token;
+  if (!token) throw new Error("Missing GitLab token");
+  const baseUrl = data.apiUrl || "https://gitlab.com";
+  const headers = {
+    "PRIVATE-TOKEN": token
+  };
+  let projects = 0;
+  let issues = 0;
+  let mrs = 0;
+  let newObjects = 0;
+  let updatedObjects = 0;
+  const projectList = await fetchAllPages(
+    `${baseUrl}/api/v4/projects?membership=true&per_page=100&order_by=last_activity_at`,
+    headers,
+    logger
+  );
+  projects = projectList.length;
+  logger.info(`Found ${projects} GitLab projects`);
+  const issuesSince = ctx.getUpdatedSince("gitlab:issues");
+  const mrsSince = ctx.getUpdatedSince("gitlab:mrs");
+  for (const project of projectList) {
+    const encodedPath = encodeURIComponent(project.path_with_namespace);
+    try {
+      let issueUrl = `${baseUrl}/api/v4/projects/${encodedPath}/issues?state=all&per_page=100&order_by=updated_at`;
+      if (issuesSince) {
+        issueUrl += `&updated_after=${issuesSince}`;
+      }
+      const issueList = await fetchAllPages(issueUrl, headers, logger);
+      const items = [];
+      for (const item of issueList) {
+        const uri = `gitlab://${project.path_with_namespace}/issue/${item.iid}`;
+        const title = `${project.path_with_namespace}#${item.iid}: ${item.title}`;
+        const body = formatGitLabIssueBody(item, project.path_with_namespace);
+        const fileContent = formatIssue({
+          source: "gitlab",
+          repo: project.path_with_namespace,
+          number: item.iid,
+          title: item.title,
+          state: item.state,
+          author: item.author?.username ?? "unknown",
+          labels: item.labels,
+          created: item.created_at,
+          uri,
+          body: item.description ?? ""
+        });
+        items.push({
+          source: "gitlab",
+          sourceType: "issue",
+          uri,
+          title,
+          summary: item.description ? item.description.length > 200 ? item.description.slice(0, 200) + "..." : item.description : item.title,
+          tags: ["gitlab", "issue", item.state, ...item.labels],
+          content: body,
+          contentType: "text/plain",
+          createdAt: new Date(item.created_at).getTime(),
+          fileContent,
+          fileMeta: { repo: project.path_with_namespace, number: item.iid }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      issues += items.length;
+    } catch (err) {
+      logger.warn(`Error fetching issues for ${project.path_with_namespace}: ${err}`);
+    }
+    try {
+      let mrUrl = `${baseUrl}/api/v4/projects/${encodedPath}/merge_requests?state=all&per_page=100&order_by=updated_at`;
+      if (mrsSince) {
+        mrUrl += `&updated_after=${mrsSince}`;
+      }
+      const mrList = await fetchAllPages(mrUrl, headers, logger);
+      const items = [];
+      for (const item of mrList) {
+        const uri = `gitlab://${project.path_with_namespace}/merge_request/${item.iid}`;
+        const title = `${project.path_with_namespace}!${item.iid}: ${item.title}`;
+        const body = formatGitLabMRBody(item, project.path_with_namespace);
+        const fileContent = formatPullRequest({
+          source: "gitlab",
+          repo: project.path_with_namespace,
+          number: item.iid,
+          title: item.title,
+          state: item.state,
+          author: item.author?.username ?? "unknown",
+          labels: item.labels,
+          created: item.created_at,
+          uri,
+          body: item.description ?? "",
+          sourceBranch: item.source_branch,
+          targetBranch: item.target_branch
+        });
+        items.push({
+          source: "gitlab",
+          sourceType: "merge_request",
+          uri,
+          title,
+          summary: item.description ? item.description.length > 200 ? item.description.slice(0, 200) + "..." : item.description : item.title,
+          tags: ["gitlab", "merge_request", item.state, ...item.labels],
+          content: body,
+          contentType: "text/plain",
+          createdAt: new Date(item.created_at).getTime(),
+          fileContent,
+          fileMeta: { repo: project.path_with_namespace, number: item.iid }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      mrs += items.length;
+    } catch (err) {
+      logger.warn(`Error fetching MRs for ${project.path_with_namespace}: ${err}`);
+    }
+    await new Promise((r) => setTimeout(r, RATE_LIMIT_DELAY_MS));
+  }
+  ctx.saveTimestampCursor("gitlab:issues");
+  ctx.saveTimestampCursor("gitlab:mrs");
+  logger.info("GitLab sync complete", { projects, issues, mrs, newObjects, updatedObjects });
+  return { projects, issues, mrs, newObjects, updatedObjects };
+}
+function formatGitLabIssueBody(item, project) {
+  return [
+    `${project}#${item.iid}: ${item.title}`,
+    `State: ${item.state} | Author: ${item.author?.username ?? "unknown"} | Created: ${item.created_at}`,
+    `Labels: ${item.labels.join(", ") || "none"}`,
+    "",
+    item.description ?? "(no description)"
+  ].join("\n");
+}
+function formatGitLabMRBody(item, project) {
+  return [
+    `${project}!${item.iid}: ${item.title}`,
+    `State: ${item.state} | Author: ${item.author?.username ?? "unknown"} | Created: ${item.created_at}`,
+    `Branch: ${item.source_branch} \u2192 ${item.target_branch}`,
+    `Labels: ${item.labels.join(", ") || "none"}`,
+    "",
+    item.description ?? "(no description)"
+  ].join("\n");
+}
+
+// src/sync/linear.ts
+var defaultLogger2 = {
+  info: (msg, ctx) => logInfo("sync", msg, ctx),
+  warn: (msg, ctx) => logError("sync", msg, ctx),
+  error: (msg, ctx) => logError("sync", msg, ctx)
+};
+var LINEAR_API = "https://api.linear.app/graphql";
+function issuesQuery(afterCursor, updatedSince) {
+  const afterClause = afterCursor ? `, after: "${afterCursor}"` : "";
+  const filterClause = updatedSince ? `, filter: { updatedAt: { gte: "${updatedSince}" } }` : "";
+  return `
+  query {
+    issues(first: 50${afterClause}, orderBy: updatedAt${filterClause}) {
+      pageInfo { hasNextPage endCursor }
+      nodes {
+        id
+        identifier
+        title
+        description
+        url
+        state { name }
+        assignee { name }
+        labels { nodes { name } }
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+}
+async function syncLinear(ctx, data, logger = defaultLogger2) {
+  const apiKey = data.apiKey;
+  if (!apiKey) throw new Error("Missing Linear API key");
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: apiKey
+  };
+  let issues = 0;
+  let newObjects = 0;
+  let updatedObjects = 0;
+  const since = ctx.getUpdatedSince("linear:issues");
+  let hasNextPage = true;
+  let endCursor = null;
+  while (hasNextPage) {
+    const res = await fetch(LINEAR_API, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: issuesQuery(endCursor, since) })
+    });
+    if (!res.ok) {
+      if (res.status === 401) throw new Error("Linear API key expired or invalid");
+      throw new Error(`Linear API error: ${res.status}`);
+    }
+    const body = await res.json();
+    if (body.errors?.length) {
+      throw new Error(`Linear GraphQL error: ${body.errors[0].message}`);
+    }
+    const issueList = body.data?.issues?.nodes ?? [];
+    issues += issueList.length;
+    const items = [];
+    for (const item of issueList) {
+      const uri = `linear://${item.identifier}`;
+      const title = `${item.identifier}: ${item.title}`;
+      const labelNames = item.labels.nodes.map((l) => l.name);
+      const bodyText = formatLinearIssueBody(item);
+      const fileContent = formatIssue({
+        source: "linear",
+        repo: item.identifier.split("-")[0] ?? "linear",
+        number: parseInt(item.identifier.split("-")[1] ?? "0"),
+        title: item.title,
+        state: item.state.name,
+        author: item.assignee?.name ?? "unassigned",
+        labels: labelNames,
+        created: item.createdAt,
+        uri,
+        body: item.description ?? ""
+      });
+      items.push({
+        source: "linear",
+        sourceType: "issue",
+        uri,
+        title,
+        summary: item.description ? item.description.length > 200 ? item.description.slice(0, 200) + "..." : item.description : item.title,
+        tags: ["linear", "issue", item.state.name, ...labelNames],
+        content: bodyText,
+        contentType: "text/plain",
+        createdAt: new Date(item.createdAt).getTime(),
+        fileContent,
+        fileMeta: { identifier: item.identifier }
+      });
+    }
+    const result = ctx.batchUpsert(items);
+    newObjects += result.inserted;
+    updatedObjects += result.updated;
+    hasNextPage = body.data?.issues?.pageInfo?.hasNextPage ?? false;
+    endCursor = body.data?.issues?.pageInfo?.endCursor ?? null;
+  }
+  logger.info(`Found ${issues} Linear issues`);
+  ctx.saveTimestampCursor("linear:issues");
+  logger.info("Linear sync complete", { issues, newObjects, updatedObjects });
+  return { issues, newObjects, updatedObjects };
+}
+function formatLinearIssueBody(item) {
+  return [
+    `${item.identifier}: ${item.title}`,
+    `State: ${item.state.name} | Assignee: ${item.assignee?.name ?? "unassigned"} | Created: ${item.createdAt}`,
+    `Labels: ${item.labels.nodes.map((l) => l.name).join(", ") || "none"}`,
+    "",
+    item.description ?? "(no description)"
+  ].join("\n");
+}
+
+export {
+  linkAllUnprocessed,
+  syncGitLab,
+  syncLinear
+};