jowork 0.2.4 → 0.3.0

package/dist/chunk-QGHJ45PL.js

@@ -0,0 +1,661 @@
+import {
+  linkAllUnprocessed,
+  syncGitLab,
+  syncLinear
+} from "./chunk-HENAABEL.js";
+import {
+  syncGitHub
+} from "./chunk-63AMINQC.js";
+import {
+  GitManager
+} from "./chunk-EYP6WMFF.js";
+import {
+  DbManager
+} from "./chunk-74AHY7X6.js";
+import {
+  listCredentials,
+  loadCredential
+} from "./chunk-54SD5GBF.js";
+import {
+  dbPath,
+  fileRepoDir
+} from "./chunk-4PIT2GZ4.js";
+import {
+  syncFeishu,
+  syncFeishuApprovals,
+  syncFeishuDocs,
+  syncFeishuLinks,
+  syncFeishuMeetings
+} from "./chunk-DQW74UCN.js";
+import {
+  formatAnalytics,
+  formatMessages
+} from "./chunk-RO3KK5RC.js";
+import {
+  logError,
+  logInfo
+} from "./chunk-MYDK7MWB.js";
+import {
+  SyncContext
+} from "./chunk-OXWWOKC7.js";
+
+// src/commands/sync.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/sync/posthog.ts
+var defaultLogger = {
+  info: (msg, ctx) => logInfo("sync", msg, ctx),
+  warn: (msg, ctx) => logError("sync", msg, ctx),
+  error: (msg, ctx) => logError("sync", msg, ctx)
+};
+async function syncPostHog(ctx, data, logger = defaultLogger) {
+  const { apiKey, host, projectId: rawProjectId } = data;
+  if (!apiKey) throw new Error("Missing PostHog API key");
+  const baseUrl = host || "https://app.posthog.com";
+  const projectId = rawProjectId || "1";
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  let events = 0, insights = 0, newObjects = 0, updatedObjects = 0;
+  try {
+    let insightsUrl = `${baseUrl}/api/projects/${projectId}/insights/?limit=100`;
+    const allInsights = [];
+    while (insightsUrl) {
+      const insightsRes = await fetch(insightsUrl, { headers });
+      if (!insightsRes.ok) {
+        logger.warn(`Failed to fetch insights: ${insightsRes.status}`);
+        break;
+      }
+      const page = await insightsRes.json();
+      allInsights.push(...page.results ?? []);
+      insightsUrl = page.next;
+      if (insightsUrl) await new Promise((r) => setTimeout(r, 200));
+    }
+    if (allInsights.length > 0) {
+      const items = [];
+      for (const insight of allInsights) {
+        const uri = `posthog://insight/${insight.id}`;
+        const summary = insight.description || `Insight: ${insight.name}`;
+        const body = JSON.stringify({
+          name: insight.name,
+          description: insight.description,
+          filters: insight.filters,
+          lastRefresh: insight.last_refresh
+        }, null, 2);
+        const fileContent = formatAnalytics({
+          name: insight.name,
+          description: insight.description,
+          filters: insight.filters,
+          lastRefresh: insight.last_refresh
+        });
+        items.push({
+          source: "posthog",
+          sourceType: "insight",
+          uri,
+          title: insight.name,
+          summary,
+          tags: ["posthog", "insight", ...Object.keys(insight.filters).slice(0, 3)],
+          content: body,
+          contentType: "application/json",
+          fileContent,
+          fileMeta: { title: insight.name }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      insights += items.length;
+      logger.info(`Synced ${insights} insights`);
+    }
+  } catch (err) {
+    logger.error(`Insights sync error: ${err}`);
+  }
+  try {
+    let eventsUrl = `${baseUrl}/api/projects/${projectId}/event_definitions/?limit=100`;
+    const allEvents = [];
+    while (eventsUrl) {
+      const eventsRes = await fetch(eventsUrl, { headers });
+      if (!eventsRes.ok) break;
+      const page = await eventsRes.json();
+      allEvents.push(...page.results ?? []);
+      eventsUrl = page.next;
+      if (eventsUrl) await new Promise((r) => setTimeout(r, 200));
+    }
+    if (allEvents.length > 0) {
+      const items = [];
+      for (const event of allEvents) {
+        const uri = `posthog://event/${event.name}`;
+        const summary = `${event.name}: ${event.description ?? "no description"} (30d volume: ${event.volume_30_day ?? "N/A"})`;
+        const body = JSON.stringify(event, null, 2);
+        const fileContent = formatAnalytics(event);
+        items.push({
+          source: "posthog",
+          sourceType: "event_definition",
+          uri,
+          title: event.name,
+          summary,
+          tags: ["posthog", "event_definition"],
+          content: body,
+          contentType: "application/json",
+          fileContent,
+          fileMeta: { title: event.name }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      events += items.length;
+      logger.info(`Synced ${events} event definitions`);
+    }
+  } catch (err) {
+    logger.error(`Events sync error: ${err}`);
+  }
+  try {
+    let actionsUrl = `${baseUrl}/api/projects/${projectId}/actions/?limit=100`;
+    while (actionsUrl) {
+      const actionsRes = await fetch(actionsUrl, { headers });
+      if (!actionsRes.ok) break;
+      const page = await actionsRes.json();
+      const items = [];
+      for (const action of page.results ?? []) {
+        const uri = `posthog://action/${action.id}`;
+        const summary = action.description || `Action: ${action.name}`;
+        const body = JSON.stringify(action, null, 2);
+        const fileContent = formatAnalytics(action);
+        items.push({
+          source: "posthog",
+          sourceType: "action",
+          uri,
+          title: action.name,
+          summary,
+          tags: ["posthog", "action"],
+          content: body,
+          contentType: "application/json",
+          createdAt: new Date(action.created_at).getTime(),
+          fileContent,
+          fileMeta: { title: action.name }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      actionsUrl = page.next;
+      if (actionsUrl) await new Promise((r) => setTimeout(r, 200));
+    }
+  } catch (err) {
+    logger.warn(`Actions sync error (non-fatal): ${err}`);
+  }
+  ctx.saveTimestampCursor("posthog:insights");
+  ctx.saveTimestampCursor("posthog:events");
+  logger.info("PostHog sync complete", { events, insights, newObjects, updatedObjects });
+  return { events, insights, newObjects, updatedObjects };
+}
+
+// src/sync/firebase.ts
+var defaultLogger2 = {
+  info: (msg, ctx) => logInfo("sync", msg, ctx),
+  warn: (msg, ctx) => logError("sync", msg, ctx),
+  error: (msg, ctx) => logError("sync", msg, ctx)
+};
+async function syncFirebase(ctx, data, logger = defaultLogger2) {
+  const { projectId, apiKey } = data;
+  if (!projectId) throw new Error("Missing Firebase project ID");
+  let events = 0, newObjects = 0, updatedObjects = 0;
+  if (apiKey) {
+    try {
+      const propertyId = data.propertyId ?? projectId;
+      const res = await fetch(
+        `https://analyticsdata.googleapis.com/v1beta/properties/${propertyId}:runReport?key=${apiKey}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            dateRanges: [{ startDate: "30daysAgo", endDate: "today" }],
+            dimensions: [{ name: "eventName" }],
+            metrics: [{ name: "eventCount" }, { name: "totalUsers" }],
+            limit: 500
+          })
+        }
+      );
+      if (res.ok) {
+        const report = await res.json();
+        const items = [];
+        for (const row of report.rows ?? []) {
+          const eventName = row.dimensionValues[0]?.value ?? "unknown";
+          const eventCount = parseInt(row.metricValues[0]?.value ?? "0");
+          const totalUsers = parseInt(row.metricValues[1]?.value ?? "0");
+          const uri = `firebase://${projectId}/event/${eventName}`;
+          const summary = `${eventName}: ${eventCount} events, ${totalUsers} users (last 30 days)`;
+          const body = JSON.stringify({ eventName, eventCount, totalUsers, period: "30daysAgo..today" }, null, 2);
+          const fileContent = formatAnalytics({ eventName, eventCount, totalUsers, period: "30daysAgo..today" });
+          items.push({
+            source: "firebase",
+            sourceType: "analytics_event",
+            uri,
+            title: eventName,
+            summary,
+            tags: ["firebase", "analytics", "event"],
+            content: body,
+            contentType: "application/json",
+            fileContent,
+            fileMeta: { title: eventName }
+          });
+        }
+        const result = ctx.batchUpsert(items);
+        newObjects += result.inserted;
+        updatedObjects += result.updated;
+        events += items.length;
+      } else {
+        logger.warn(`Firebase Analytics API: ${res.status}`);
+      }
+    } catch (err) {
+      logger.error(`Firebase sync error: ${err}`);
+    }
+  } else {
+    logger.warn("Firebase sync requires apiKey. Provide via jowork connect firebase --api-key <key>");
+  }
+  ctx.saveTimestampCursor("firebase:analytics");
+  logger.info("Firebase sync complete", { events, newObjects, updatedObjects });
+  return { events, newObjects, updatedObjects };
+}
+
+// src/sync/file-writer.ts
+import { writeFileSync, readFileSync, appendFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+
+// src/utils/slugify.ts
+function slugify(name) {
+  return name.replace(/[\/\\:*?"<>|]/g, "-").replace(/\s+/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "").slice(0, 100) || "untitled";
+}
+
+// src/sync/sanitizer.ts
+var SENSITIVE_PATTERNS = [
+  /Bearer [A-Za-z0-9\-._~+/]+=*/g,
+  /[A-Za-z0-9+/]{40,}/g,
+  /sk-[a-zA-Z0-9]{20,}/g,
+  /ghp_[a-zA-Z0-9]{36}/g,
+  /xoxb-[0-9]{10,}-[a-zA-Z0-9]{20,}/g,
+  /glpat-[a-zA-Z0-9\-]{20,}/g,
+  /-----BEGIN (RSA |EC )?PRIVATE KEY-----[\s\S]*?-----END/g
+];
+function sanitizeContent(content) {
+  let result = content;
+  for (const pattern of SENSITIVE_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+
+// src/sync/file-writer.ts
+var FileWriter = class {
+  repoDir;
+  constructor(repoDir) {
+    this.repoDir = repoDir ?? fileRepoDir();
+    try {
+      chmodSync(this.repoDir, 448);
+    } catch {
+    }
+  }
+  /** Write an object to a file. Returns the relative path from repoDir. */
+  writeObject(source, sourceType, meta, content) {
+    const filePath = this.getFilePath(source, sourceType, meta);
+    const absPath = join(this.repoDir, filePath);
+    mkdirSync(dirname(absPath), { recursive: true });
+    writeFileSync(absPath, sanitizeContent(content));
+    return filePath;
+  }
+  /** Append messages to a day file (for message-type sources). */
+  appendMessages(source, chatName, chatId, date, messages) {
+    const dir = join(source, "messages", slugify(chatName));
+    const filePath = join(dir, `${date}.md`);
+    const absPath = join(this.repoDir, filePath);
+    mkdirSync(dirname(absPath), { recursive: true });
+    let existingHeaders = [];
+    if (existsSync(absPath)) {
+      const existing = readFileSync(absPath, "utf-8");
+      existingHeaders = [...existing.matchAll(/^## .+/gm)].map((m) => m[0]);
+    }
+    const newMessages = messages.filter((m) => {
+      const header2 = `## ${m.time} \u2014 ${m.sender}`;
+      return !existingHeaders.includes(header2);
+    });
+    if (newMessages.length === 0) return filePath;
+    if (!existsSync(absPath)) {
+      writeFileSync(absPath, formatMessages(chatName, chatId, date, newMessages));
+    } else {
+      const appendText = newMessages.map((m) => `
+## ${m.time} \u2014 ${m.sender}
+${sanitizeContent(m.content)}`).join("\n");
+      appendFileSync(absPath, appendText + "\n");
+    }
+    return filePath;
+  }
+  /** Calculate file path for an object based on source + type. */
+  getFilePath(source, sourceType, meta) {
+    switch (source) {
+      case "github":
+      case "gitlab": {
+        const repo = slugify(meta.repo ?? "unknown");
+        const typeDir = sourceType === "pull_request" ? "pulls" : sourceType === "merge_request" ? "merge-requests" : "issues";
+        return join(source, repo, typeDir, `${meta.number ?? meta.id}.md`);
+      }
+      case "linear":
+        return join("linear", "issues", `${meta.identifier ?? meta.id}.md`);
+      case "feishu": {
+        if (sourceType === "calendar_event")
+          return join("feishu", "meetings", `${meta.date}-${slugify(meta.title ?? "event")}.md`);
+        if (sourceType === "approval")
+          return join("feishu", "approvals", `${slugify(meta.title ?? "approval")}-${meta.id}.md`);
+        if (sourceType === "document")
+          return join("feishu", "docs", `${slugify(meta.title ?? "doc")}.md`);
+        if (sourceType === "link")
+          return join("feishu", "links", `${slugify(meta.title ?? meta.id)}.md`);
+        return join("feishu", "other", `${meta.id}.md`);
+      }
+      case "posthog":
+        return join(
+          "posthog",
+          sourceType === "insight" ? "insights" : "events",
+          `${slugify(meta.title ?? meta.id)}.json`
+        );
+      case "firebase":
+        return join(
+          "firebase",
+          "analytics",
+          `${slugify(meta.title ?? meta.id)}.json`
+        );
+      case "notion":
+        return join("notion", "pages", `${slugify(meta.title ?? meta.id)}.md`);
+      case "jira":
+        return join("jira", slugify(meta.project ?? "unknown"), `${meta.identifier ?? meta.id}.md`);
+      case "sentry":
+        return join("sentry", "issues", `${meta.id}.json`);
+      default:
+        return join(source, `${meta.id}.md`);
+    }
+  }
+  get rootDir() {
+    return this.repoDir;
+  }
+};
+
+// src/commands/sync.ts
+var isTTY = process.stdout.isTTY;
+var c = {
+  reset: isTTY ? "\x1B[0m" : "",
+  bold: isTTY ? "\x1B[1m" : "",
+  dim: isTTY ? "\x1B[2m" : "",
+  green: isTTY ? "\x1B[32m" : "",
+  yellow: isTTY ? "\x1B[33m" : "",
+  red: isTTY ? "\x1B[31m" : "",
+  cyan: isTTY ? "\x1B[36m" : "",
+  gray: isTTY ? "\x1B[90m" : "",
+  white: isTTY ? "\x1B[37m" : "",
+  bgGreen: isTTY ? "\x1B[42m" : "",
+  bgRed: isTTY ? "\x1B[41m" : "",
+  bgYellow: isTTY ? "\x1B[43m" : ""
+};
+var icon = {
+  ok: `${c.green}\u2713${c.reset}`,
+  warn: `${c.yellow}\u26A0${c.reset}`,
+  fail: `${c.red}\u2717${c.reset}`,
+  skip: `${c.gray}\u25CB${c.reset}`,
+  sync: `${c.cyan}\u21BB${c.reset}`,
+  link: `${c.cyan}\u27E1${c.reset}`,
+  git: `${c.gray}\u2387${c.reset}`
+};
+function header(text) {
+  console.log("");
+  console.log(`  ${c.bold}${text}${c.reset}`);
+  console.log(`  ${c.dim}${"\u2500".repeat(Math.min(text.length + 4, 50))}${c.reset}`);
+}
+function progressBar(current, total, width = 20) {
+  const pct = total > 0 ? current / total : 0;
+  const filled = Math.round(pct * width);
+  const empty = width - filled;
+  const bar = `${c.green}${"\u2588".repeat(filled)}${c.gray}${"\u2591".repeat(empty)}${c.reset}`;
+  return `${bar} ${c.dim}${current}/${total}${c.reset}`;
+}
+function sourceLabel(name) {
+  const colors = {
+    feishu: c.cyan,
+    github: c.white,
+    gitlab: c.yellow,
+    linear: c.cyan,
+    posthog: c.red,
+    firebase: c.yellow
+  };
+  return `${colors[name] ?? c.white}${c.bold}${name}${c.reset}`;
+}
+function resultLine(ok, msg) {
+  console.log(`    ${ok ? icon.ok : icon.warn} ${msg}`);
+}
+function elapsed(start) {
+  const ms = Date.now() - start;
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+function getSyncErrorHint(source, error) {
+  const is401 = /401|unauthorized|auth.*fail/i.test(error);
+  const is403 = /403|forbidden/i.test(error);
+  if (is401 || is403) {
+    switch (source) {
+      case "github":
+        return "Token invalid or expired. Create a new one at https://github.com/settings/tokens";
+      case "gitlab":
+        return "Token invalid. Check at https://gitlab.com/-/profile/personal_access_tokens";
+      case "feishu":
+        return "App ID/Secret invalid. Check at https://open.feishu.cn/app";
+      case "linear":
+        return "API key invalid. Get one at https://linear.app/settings/api";
+      case "posthog":
+        return "API key invalid. Get one at https://app.posthog.com/project/settings";
+      case "firebase":
+        return "API key invalid. Check at https://console.cloud.google.com \u2192 APIs & Services \u2192 Credentials";
+    }
+  }
+  if (/ENOTFOUND|ECONNREFUSED|network/i.test(error)) {
+    return "Network error. Check your internet connection and try again.";
+  }
+  return null;
+}
+async function runSync(sources) {
+  const db = new DbManager(dbPath());
+  db.ensureTables();
+  const fileWriter = new FileWriter();
+  const syncResults = [];
+  const t0 = Date.now();
+  let totalNew = 0;
+  let gitManager = null;
+  try {
+    gitManager = new GitManager(fileRepoDir());
+    await gitManager.init();
+  } catch {
+  }
+  header(`Syncing ${sources.length} source${sources.length > 1 ? "s" : ""}`);
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    const cred = loadCredential(source);
+    if (!cred) {
+      console.log(`  ${icon.skip} ${sourceLabel(source)} ${c.dim}no credentials, skipping${c.reset}`);
+      continue;
+    }
+    const sourceStart = Date.now();
+    console.log(`  ${icon.sync} ${sourceLabel(source)} ${c.dim}syncing...${c.reset}`);
+    const logger = {
+      info: (_msg) => {
+      },
+      warn: (msg) => resultLine(false, `${c.dim}${msg}${c.reset}`),
+      error: (msg) => console.error(`    ${icon.fail} ${c.red}${msg}${c.reset}`)
+    };
+    try {
+      switch (source) {
+        case "feishu": {
+          const feishuCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const result = await syncFeishu(feishuCtx, cred.data, logger);
+          resultLine(true, `${result.newMessages} new messages from ${result.chats} chats`);
+          totalNew += result.newMessages;
+          syncResults.push({ source: "feishu", newObjects: result.newMessages, label: "messages" });
+          try {
+            const mr = await syncFeishuMeetings(feishuCtx, cred.data, logger);
+            if (mr.newObjects > 0) resultLine(true, `${mr.newObjects} calendar events`);
+            syncResults.push({ source: "feishu/meetings", newObjects: mr.newObjects, label: "events" });
+          } catch {
+          }
+          try {
+            const dr = await syncFeishuDocs(feishuCtx, cred.data, logger);
+            if (dr.newObjects > 0) resultLine(true, `${dr.newObjects} documents`);
+            syncResults.push({ source: "feishu/docs", newObjects: dr.newObjects, label: "docs" });
+          } catch {
+          }
+          try {
+            const ar = await syncFeishuApprovals(feishuCtx, cred.data, logger);
+            if (ar.newObjects > 0) resultLine(true, `${ar.newObjects} approvals`);
+            syncResults.push({ source: "feishu/approvals", newObjects: ar.newObjects, label: "approvals" });
+          } catch {
+          }
+          try {
+            const lr = await syncFeishuLinks(feishuCtx, cred.data, logger);
+            if (lr.fetched > 0) resultLine(true, `${lr.fetched} link contents fetched (${lr.extracted} URLs found)`);
+            else if (lr.extracted > 0) resultLine(false, `${lr.extracted} URLs found, ${lr.failed} failed to fetch`);
+            syncResults.push({ source: "feishu/links", newObjects: lr.fetched, label: "links" });
+          } catch {
+          }
+          break;
+        }
+        case "github": {
+          const ghCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncGitHub(ghCtx, cred.data, logger);
+          const changeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          const cloneInfo = r.clonedRepos > 0 ? ` | ${r.clonedRepos} repos cloned` : "";
+          resultLine(true, `${r.repos} repos, ${r.prs} PRs, ${r.issues} issues ${c.dim}(${r.newObjects} new${changeInfo})${cloneInfo}${c.reset}`);
+          totalNew += r.newObjects;
+          syncResults.push({ source: "github", newObjects: r.newObjects + r.updatedObjects });
+          break;
+        }
+        case "gitlab": {
+          const glCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncGitLab(glCtx, cred.data, logger);
+          const glChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.projects} projects, ${r.mrs} MRs, ${r.issues} issues ${c.dim}(${r.newObjects} new${glChangeInfo})${c.reset}`);
+          totalNew += r.newObjects;
+          syncResults.push({ source: "gitlab", newObjects: r.newObjects + r.updatedObjects });
+          break;
+        }
+        case "linear": {
+          const lnCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncLinear(lnCtx, cred.data, logger);
+          const lnChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.issues} issues ${c.dim}(${r.newObjects} new${lnChangeInfo})${c.reset}`);
+          totalNew += r.newObjects;
+          syncResults.push({ source: "linear", newObjects: r.newObjects + r.updatedObjects, label: "issues" });
+          break;
+        }
+        case "posthog": {
+          const phCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncPostHog(phCtx, cred.data, logger);
+          const phChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.insights} insights, ${r.events} events ${c.dim}(${r.newObjects} new${phChangeInfo})${c.reset}`);
+          totalNew += r.newObjects;
+          syncResults.push({ source: "posthog", newObjects: r.newObjects + r.updatedObjects });
+          break;
+        }
+        case "firebase": {
+          const fbCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncFirebase(fbCtx, cred.data, logger);
+          const fbChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.events} events ${c.dim}(${r.newObjects} new${fbChangeInfo})${c.reset}`);
+          totalNew += r.newObjects;
+          syncResults.push({ source: "firebase", newObjects: r.newObjects + r.updatedObjects, label: "events" });
+          break;
+        }
+        default:
+          console.log(`    ${icon.skip} ${c.dim}unknown source${c.reset}`);
+      }
+      console.log(`    ${c.dim}${elapsed(sourceStart)}${c.reset}`);
+    } catch (err) {
+      logError("sync", `Failed to sync ${source}`, { error: String(err) });
+      const errStr = String(err);
+      console.log(`    ${icon.fail} ${c.red}sync failed${c.reset} ${c.dim}${errStr.slice(0, 60)}${c.reset}`);
+      const hint = getSyncErrorHint(source, errStr);
+      if (hint) {
+        console.log(`    ${c.yellow}Hint: ${hint}${c.reset}`);
+      }
+    }
+    if (sources.length > 1) {
+      console.log(`  ${progressBar(i + 1, sources.length)}`);
+    }
+  }
+  console.log("");
+  console.log(`  ${icon.link} ${c.dim}extracting links...${c.reset}`);
+  const { processed, linksCreated } = linkAllUnprocessed(db.getSqlite());
+  if (processed > 0) {
+    resultLine(true, `${linksCreated} links from ${processed} objects`);
+  }
+  try {
+    const sqlite = db.getSqlite();
+    const { readObjectContent } = await import("./content-reader-VPGTR2SF.js");
+    const noFilePath = sqlite.prepare(`
+      SELECT o.id, o.source, o.source_type, o.uri, o.title
+      FROM objects o
+      WHERE o.file_path IS NULL
+      LIMIT 500
+    `).all();
+    if (noFilePath.length > 0) {
+      console.log(`  ${icon.sync} ${c.dim}backfilling ${noFilePath.length} objects without files...${c.reset}`);
+      let backfilled = 0;
+      for (const obj of noFilePath) {
+        try {
+          const content = readObjectContent(sqlite, obj.id, null);
+          if (!content) continue;
+          const filePath = fileWriter.writeObject(obj.source, obj.source_type, {
+            id: obj.id,
+            title: obj.title,
+            uri: obj.uri
+          }, content);
+          sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, obj.id);
+          backfilled++;
+        } catch {
+        }
+      }
+      if (backfilled > 0) {
+        resultLine(true, `${backfilled} files backfilled`);
+      }
+    }
+  } catch {
+  }
+  db.close();
+  if (gitManager) {
+    try {
+      const sha = await gitManager.commitSync({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), sources: syncResults });
+      if (sha) console.log(`  ${icon.git} ${c.dim}committed ${sha.slice(0, 7)}${c.reset}`);
+    } catch {
+    }
+  }
+  console.log("");
+  console.log(`  ${c.bold}${c.green}Done${c.reset} ${c.dim}in ${elapsed(t0)}${c.reset}`);
+  console.log(`  ${c.bold}${totalNew}${c.reset} new objects synced from ${c.bold}${syncResults.length}${c.reset} sources`);
+  console.log("");
+}
+function syncCommand(program) {
+  program.command("sync").description("Sync data from connected sources").option("--source <source>", "Sync specific source only").action(async (opts) => {
+    if (!existsSync2(dbPath())) {
+      console.error("Error: JoWork not initialized. Run `jowork init` first.");
+      process.exit(1);
+    }
+    const sources = opts.source ? [opts.source] : listCredentials();
+    if (sources.length === 0) {
+      console.log("No data sources connected. Run `jowork connect <source>` first.");
+      return;
+    }
+    await runSync(sources);
+  });
+}
+
+export {
+  syncPostHog,
+  syncFirebase,
+  FileWriter,
+  runSync,
+  syncCommand
+};