jowork 0.1.0 → 0.2.1

package/dist/chunk-AIXKXEYS.js

@@ -0,0 +1,547 @@
+import {
+  linkAllUnprocessed,
+  syncGitLab,
+  syncLinear
+} from "./chunk-YJWTKFWX.js";
+import {
+  DbManager
+} from "./chunk-XAEGXSEO.js";
+import {
+  listCredentials,
+  loadCredential
+} from "./chunk-XLYRHKG6.js";
+import {
+  dbPath,
+  fileRepoDir
+} from "./chunk-ROIINI33.js";
+import {
+  syncGitHub
+} from "./chunk-LS2AJM5A.js";
+import {
+  contentHash,
+  formatAnalytics,
+  formatMessages,
+  syncFeishu,
+  syncFeishuApprovals,
+  syncFeishuDocs,
+  syncFeishuMeetings
+} from "./chunk-QMOFQX7X.js";
+import {
+  createId
+} from "./chunk-JE6TOU7W.js";
+import {
+  GitManager
+} from "./chunk-L5ZR7TSK.js";
+import {
+  logError,
+  logInfo
+} from "./chunk-MYDK7MWB.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(sqlite, data, logger = defaultLogger, fileWriter) {
+  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;
+  const checkExists = sqlite.prepare("SELECT id FROM objects WHERE uri = ?");
+  const insertObj = sqlite.prepare(`
+    INSERT INTO objects (id, source, source_type, uri, title, summary, tags, content_hash, last_synced_at, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertBody = sqlite.prepare(`
+    INSERT OR REPLACE INTO object_bodies (object_id, content, content_type, fetched_at)
+    VALUES (?, ?, ?, ?)
+  `);
+  const insertFts = sqlite.prepare(`
+    INSERT INTO objects_fts(rowid, title, summary, tags, source, source_type, body_excerpt)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const getRowid = sqlite.prepare("SELECT rowid FROM objects WHERE id = ?");
+  try {
+    const insightsRes = await fetch(`${baseUrl}/api/projects/${projectId}/insights/?limit=50`, { headers });
+    if (insightsRes.ok) {
+      const insightsData = await insightsRes.json();
+      const batch = sqlite.transaction((items) => {
+        for (const insight of items) {
+          const uri = `posthog://insight/${insight.id}`;
+          if (checkExists.get(uri)) continue;
+          const now = Date.now();
+          const id = createId("obj");
+          const summary = insight.description || `Insight: ${insight.name}`;
+          const tags = JSON.stringify(["posthog", "insight", ...Object.keys(insight.filters).slice(0, 3)]);
+          const body = JSON.stringify({
+            name: insight.name,
+            description: insight.description,
+            filters: insight.filters,
+            lastRefresh: insight.last_refresh
+          }, null, 2);
+          insertObj.run(id, "posthog", "insight", uri, insight.name, summary, tags, contentHash(body), now, now);
+          insertBody.run(id, body, "application/json", now);
+          try {
+            const rowid = getRowid.get(id);
+            if (rowid) {
+              const excerpt = body.length > 500 ? body.slice(0, 500) : body;
+              insertFts.run(rowid.rowid, insight.name ?? "", summary ?? "", tags, "posthog", "insight", excerpt);
+            }
+          } catch {
+          }
+          if (fileWriter) {
+            try {
+              const fileContent = formatAnalytics({
+                name: insight.name,
+                description: insight.description,
+                filters: insight.filters,
+                lastRefresh: insight.last_refresh
+              });
+              const filePath = fileWriter.writeObject("posthog", "insight", {
+                id,
+                title: insight.name
+              }, fileContent);
+              sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, id);
+            } catch {
+            }
+          }
+          insights++;
+          newObjects++;
+        }
+      });
+      batch(insightsData.results ?? []);
+      logger.info(`Synced ${insights} insights`);
+    } else {
+      logger.warn(`Failed to fetch insights: ${insightsRes.status}`);
+    }
+  } catch (err) {
+    logger.error(`Insights sync error: ${err}`);
+  }
+  try {
+    const eventsRes = await fetch(`${baseUrl}/api/projects/${projectId}/event_definitions/?limit=100`, { headers });
+    if (eventsRes.ok) {
+      const eventsData = await eventsRes.json();
+      const batch = sqlite.transaction((items) => {
+        for (const event of items) {
+          const uri = `posthog://event/${event.name}`;
+          if (checkExists.get(uri)) continue;
+          const now = Date.now();
+          const id = createId("obj");
+          const summary = `${event.name}: ${event.description ?? "no description"} (30d volume: ${event.volume_30_day ?? "N/A"})`;
+          const tags = JSON.stringify(["posthog", "event_definition"]);
+          const body = JSON.stringify(event, null, 2);
+          insertObj.run(id, "posthog", "event_definition", uri, event.name, summary, tags, contentHash(body), now, now);
+          insertBody.run(id, body, "application/json", now);
+          try {
+            const rowid = getRowid.get(id);
+            if (rowid) {
+              const excerpt = body.length > 500 ? body.slice(0, 500) : body;
+              insertFts.run(rowid.rowid, event.name ?? "", summary ?? "", tags, "posthog", "event_definition", excerpt);
+            }
+          } catch {
+          }
+          if (fileWriter) {
+            try {
+              const fileContent = formatAnalytics(event);
+              const filePath = fileWriter.writeObject("posthog", "event_definition", {
+                id,
+                title: event.name
+              }, fileContent);
+              sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, id);
+            } catch {
+            }
+          }
+          events++;
+          newObjects++;
+        }
+      });
+      batch(eventsData.results ?? []);
+      logger.info(`Synced ${events} event definitions`);
+    }
+  } catch (err) {
+    logger.error(`Events sync error: ${err}`);
+  }
+  logger.info("PostHog sync complete", { events, insights, newObjects });
+  return { events, insights, newObjects };
+}
+
+// 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(sqlite, data, logger = defaultLogger2, fileWriter) {
+  const { projectId, apiKey } = data;
+  if (!projectId) throw new Error("Missing Firebase project ID");
+  let events = 0, newObjects = 0;
+  const checkExists = sqlite.prepare("SELECT id FROM objects WHERE uri = ?");
+  const insertObj = sqlite.prepare(`
+    INSERT INTO objects (id, source, source_type, uri, title, summary, tags, content_hash, last_synced_at, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertBody = sqlite.prepare(`
+    INSERT OR REPLACE INTO object_bodies (object_id, content, content_type, fetched_at)
+    VALUES (?, ?, ?, ?)
+  `);
+  const insertFts = sqlite.prepare(`
+    INSERT INTO objects_fts(rowid, title, summary, tags, source, source_type, body_excerpt)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const getRowid = sqlite.prepare("SELECT rowid FROM objects WHERE id = ?");
+  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: "7daysAgo", endDate: "today" }],
+            dimensions: [{ name: "eventName" }],
+            metrics: [{ name: "eventCount" }],
+            limit: 50
+          })
+        }
+      );
+      if (res.ok) {
+        const report = await res.json();
+        const batch = sqlite.transaction((rows) => {
+          for (const row of rows) {
+            const eventName = row.dimensionValues[0]?.value ?? "unknown";
+            const eventCount = parseInt(row.metricValues[0]?.value ?? "0");
+            const uri = `firebase://${projectId}/event/${eventName}`;
+            if (checkExists.get(uri)) continue;
+            const nowMs = Date.now();
+            const id = createId("obj");
+            const summary = `${eventName}: ${eventCount} events (last 7 days)`;
+            const tags = JSON.stringify(["firebase", "analytics", "event"]);
+            const body = JSON.stringify({ eventName, eventCount, period: "7daysAgo..today" }, null, 2);
+            insertObj.run(id, "firebase", "analytics_event", uri, eventName, summary, tags, contentHash(body), nowMs, nowMs);
+            insertBody.run(id, body, "application/json", nowMs);
+            try {
+              const rowid = getRowid.get(id);
+              if (rowid) {
+                insertFts.run(rowid.rowid, eventName ?? "", summary ?? "", tags, "firebase", "analytics_event", body.length > 500 ? body.slice(0, 500) : body);
+              }
+            } catch {
+            }
+            if (fileWriter) {
+              try {
+                const fileContent = formatAnalytics({ eventName, eventCount, period: "7daysAgo..today" });
+                const filePath = fileWriter.writeObject("firebase", "analytics_event", {
+                  id,
+                  title: eventName
+                }, fileContent);
+                sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, id);
+              } catch {
+              }
+            }
+            events++;
+            newObjects++;
+          }
+        });
+        batch(report.rows ?? []);
+      } 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>");
+  }
+  logger.info("Firebase sync complete", { events, newObjects });
+  return { events, newObjects };
+}
+
+// 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 header = `## ${m.time} \u2014 ${m.sender}`;
+      return !existingHeaders.includes(header);
+    });
+    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`);
+        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
+async function runSync(sources) {
+  const db = new DbManager(dbPath());
+  db.ensureTables();
+  const fileWriter = new FileWriter();
+  const syncResults = [];
+  let gitManager = null;
+  try {
+    gitManager = new GitManager(fileRepoDir());
+    await gitManager.init();
+  } catch {
+  }
+  for (const source of sources) {
+    const cred = loadCredential(source);
+    if (!cred) {
+      console.log(`\u2298 ${source}: no credentials found, skipping`);
+      continue;
+    }
+    console.log(`Syncing ${source}...`);
+    try {
+      switch (source) {
+        case "feishu": {
+          const logger = {
+            info: (msg) => console.log(`  ${msg}`),
+            warn: (msg) => console.log(`  \u26A0 ${msg}`),
+            error: (msg) => console.error(`  \u2717 ${msg}`)
+          };
+          const result = await syncFeishu(db.getSqlite(), cred.data, logger, fileWriter);
+          console.log(`  \u2713 Synced ${result.totalMessages} messages (${result.newMessages} new) from ${result.chats} chats`);
+          syncResults.push({ source: "feishu", newObjects: result.newMessages, label: "messages" });
+          try {
+            const meetResult = await syncFeishuMeetings(db.getSqlite(), cred.data, logger, fileWriter);
+            if (meetResult.meetings > 0) {
+              console.log(`  \u2713 Synced ${meetResult.meetings} calendar events (${meetResult.newObjects} new)`);
+              syncResults.push({ source: "feishu/meetings", newObjects: meetResult.newObjects, label: "events" });
+            }
+          } catch (err) {
+            console.log(`  \u26A0 Meeting sync: ${err}`);
+          }
+          try {
+            const docResult = await syncFeishuDocs(db.getSqlite(), cred.data, logger, fileWriter);
+            if (docResult.docs > 0) {
+              console.log(`  \u2713 Synced ${docResult.docs} documents (${docResult.newObjects} new)`);
+              syncResults.push({ source: "feishu/docs", newObjects: docResult.newObjects, label: "docs" });
+            }
+          } catch (err) {
+            console.log(`  \u26A0 Document sync: ${err}`);
+          }
+          try {
+            const approvalResult = await syncFeishuApprovals(db.getSqlite(), cred.data, logger, fileWriter);
+            if (approvalResult.approvals > 0) {
+              console.log(`  \u2713 Synced ${approvalResult.approvals} approvals (${approvalResult.newObjects} new)`);
+              syncResults.push({ source: "feishu/approvals", newObjects: approvalResult.newObjects, label: "approvals" });
+            }
+          } catch (err) {
+            console.log(`  \u26A0 Approval sync: ${err}`);
+          }
+          break;
+        }
+        case "github": {
+          const ghLogger = {
+            info: (msg) => console.log(`  ${msg}`),
+            warn: (msg) => console.log(`  \u26A0 ${msg}`),
+            error: (msg) => console.error(`  \u2717 ${msg}`)
+          };
+          const result = await syncGitHub(db.getSqlite(), cred.data, ghLogger, fileWriter);
+          console.log(`  \u2713 Synced ${result.repos} repos: ${result.issues} issues, ${result.prs} PRs (${result.newObjects} new)`);
+          syncResults.push({ source: "github", newObjects: result.newObjects });
+          break;
+        }
+        case "gitlab": {
+          const glLogger = {
+            info: (msg) => console.log(`  ${msg}`),
+            warn: (msg) => console.log(`  \u26A0 ${msg}`),
+            error: (msg) => console.error(`  \u2717 ${msg}`)
+          };
+          const glResult = await syncGitLab(db.getSqlite(), cred.data, glLogger, fileWriter);
+          console.log(`  \u2713 Synced ${glResult.projects} projects: ${glResult.issues} issues, ${glResult.mrs} MRs (${glResult.newObjects} new)`);
+          syncResults.push({ source: "gitlab", newObjects: glResult.newObjects });
+          break;
+        }
+        case "linear": {
+          const linLogger = {
+            info: (msg) => console.log(`  ${msg}`),
+            warn: (msg) => console.log(`  \u26A0 ${msg}`),
+            error: (msg) => console.error(`  \u2717 ${msg}`)
+          };
+          const linResult = await syncLinear(db.getSqlite(), cred.data, linLogger, fileWriter);
+          console.log(`  \u2713 Synced ${linResult.issues} Linear issues (${linResult.newObjects} new)`);
+          syncResults.push({ source: "linear", newObjects: linResult.newObjects, label: "issues" });
+          break;
+        }
+        case "posthog": {
+          const phLogger = {
+            info: (msg) => console.log(`  ${msg}`),
+            warn: (msg) => console.log(`  \u26A0 ${msg}`),
+            error: (msg) => console.error(`  \u2717 ${msg}`)
+          };
+          const phResult = await syncPostHog(db.getSqlite(), cred.data, phLogger, fileWriter);
+          console.log(`  \u2713 Synced ${phResult.insights} insights, ${phResult.events} events (${phResult.newObjects} new)`);
+          syncResults.push({ source: "posthog", newObjects: phResult.newObjects });
+          break;
+        }
+        case "firebase": {
+          const fbLogger = {
+            info: (msg) => console.log(`  ${msg}`),
+            warn: (msg) => console.log(`  \u26A0 ${msg}`),
+            error: (msg) => console.error(`  \u2717 ${msg}`)
+          };
+          const fbResult = await syncFirebase(db.getSqlite(), cred.data, fbLogger, fileWriter);
+          console.log(`  \u2713 Synced ${fbResult.events} Firebase events (${fbResult.newObjects} new)`);
+          syncResults.push({ source: "firebase", newObjects: fbResult.newObjects, label: "events" });
+          break;
+        }
+        default:
+          console.log(`  Unknown source: ${source}`);
+      }
+    } catch (err) {
+      logError("sync", `Failed to sync ${source}`, { error: String(err) });
+      console.error(`  \u2717 ${source} sync failed: ${err}`);
+    }
+  }
+  console.log("Running entity extraction...");
+  const { processed, linksCreated } = linkAllUnprocessed(db.getSqlite());
+  console.log(`  \u2713 Extracted ${linksCreated} links from ${processed} objects`);
+  db.close();
+  if (gitManager) {
+    try {
+      const sha = await gitManager.commitSync({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sources: syncResults
+      });
+      if (sha) {
+        console.log(`  \u2713 Committed: ${sha.slice(0, 7)}`);
+      }
+    } catch (err) {
+      logError("sync", "Git commit failed", { error: String(err) });
+    }
+  }
+}
+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
+};