jowork 0.1.0

package/dist/chunk-S24PDC46.js

@@ -0,0 +1,569 @@
+import {
+  buildFtsQuery,
+  connectorConfigs,
+  createId,
+  detectSourceFromQuery,
+  memories,
+  objectBodies,
+  objects
+} from "./chunk-3NMLDZBL.js";
+
+// src/utils/paths.ts
+import { join } from "path";
+import { mkdirSync } from "fs";
+var HOME = process.env["HOME"] ?? "/tmp";
+function joworkDir() {
+  return join(HOME, ".jowork");
+}
+function dataDir() {
+  const dir = join(joworkDir(), "data");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function dbPath() {
+  return join(dataDir(), "jowork.db");
+}
+function credentialsDir() {
+  const dir = join(joworkDir(), "credentials");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function configPath() {
+  return join(joworkDir(), "config.json");
+}
+function logsDir() {
+  const dir = join(joworkDir(), "logs");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { like, eq, or, desc } from "drizzle-orm";
+import { existsSync, readFileSync } from "fs";
+import { join as join3 } from "path";
+
+// src/utils/logger.ts
+import { pino } from "pino";
+import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+function getLogDir() {
+  const dir = join2(process.env["HOME"] ?? "/tmp", ".jowork", "logs");
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+var logger = pino({
+  level: process.env["LOG_LEVEL"] ?? "info",
+  transport: process.env["JOWORK_LOG_FILE"] ? { target: "pino/file", options: { destination: join2(getLogDir(), "jowork.log") } } : { target: "pino-pretty", options: { destination: 2 } }
+  // stderr
+});
+function logInfo(category, msg, ctx) {
+  logger.info({ category, ...ctx }, msg);
+}
+function logError(category, msg, ctx) {
+  logger.error({ category, ...ctx }, msg);
+}
+
+// src/mcp/server.ts
+function escapeLike(input) {
+  return input.replace(/[%_\\]/g, "\\$&");
+}
+function escapeFtsQuery(query) {
+  return query.split(/\s+/).filter(Boolean).map((token) => {
+    if (/^(AND|OR|NOT|NEAR)$/i.test(token) || /[*"(){}:^~\-+[\]]/g.test(token)) {
+      return `"${token.replace(/"/g, '""')}"`;
+    }
+    return token;
+  }).join(" ");
+}
+var MAX_MEMORIES = 100;
+function createJoWorkMcpServer(opts) {
+  const sqlite = new Database(opts.dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  const db = drizzle(sqlite);
+  const server = new McpServer({ name: "jowork", version: "0.1.0" });
+  server.server.onclose = () => {
+    try {
+      sqlite.close();
+    } catch {
+    }
+  };
+  server.tool(
+    "search_data",
+    {
+      query: z.string().describe("Keywords to search -- works like grep across all synced data"),
+      source: z.string().optional().describe("Filter by data source: github, feishu, gitlab, notion, slack, local"),
+      limit: z.number().optional().default(20).describe("Max results (default 20)")
+    },
+    async ({ query, source, limit }) => {
+      const t0 = Date.now();
+      if (!source) {
+        source = detectSourceFromQuery(query) ?? void 0;
+      }
+      const ftsMatchQuery = buildFtsQuery(query);
+      if (ftsMatchQuery) {
+        try {
+          const ftsQuery = source ? `SELECT o.id, o.title, o.summary, o.source, o.source_type, o.uri, o.tags
+               FROM objects_fts JOIN objects o ON o.rowid = objects_fts.rowid
+               WHERE objects_fts MATCH ? AND o.source = ? LIMIT ?` : `SELECT o.id, o.title, o.summary, o.source, o.source_type, o.uri, o.tags
+               FROM objects_fts JOIN objects o ON o.rowid = objects_fts.rowid
+               WHERE objects_fts MATCH ? LIMIT ?`;
+          const ftsArgs = source ? [ftsMatchQuery, source, limit] : [ftsMatchQuery, limit];
+          const ftsResults = sqlite.prepare(ftsQuery).all(...ftsArgs);
+          if (ftsResults.length > 0) {
+            logInfo("mcp", `search_data: "${query}" (FTS)`, { source, resultCount: ftsResults.length, ms: Date.now() - t0 });
+            return { content: [{ type: "text", text: JSON.stringify(ftsResults, null, 2) }] };
+          }
+        } catch {
+        }
+      }
+      const cleanedQuery = query.replace(/飞书|feishu|lark|github|gitlab|notion|slack/gi, "").replace(/群里|最近|在|讨论|什么|话题|有哪些|是什么|怎么样|帮我|告诉我|查一下/g, "").trim();
+      let rows = [];
+      if (source && cleanedQuery.length >= 2) {
+        const segments = cleanedQuery.split(/\s+/).filter((s) => s.length >= 2);
+        if (segments.length > 0) {
+          const conditions = segments.map(() => "(title LIKE ? OR summary LIKE ? OR tags LIKE ?)").join(" OR ");
+          const params = [];
+          for (const seg of segments) {
+            const p = `%${escapeLike(seg)}%`;
+            params.push(p, p, p);
+          }
+          params.push(source, limit);
+          rows = sqlite.prepare(`
+            SELECT id, title, summary, source, source_type, uri, tags FROM objects
+            WHERE (${conditions}) AND source = ? ORDER BY last_synced_at DESC LIMIT ?
+          `).all(...params);
+        } else {
+          rows = [];
+        }
+      } else if (source) {
+        rows = sqlite.prepare(`
+          SELECT id, title, summary, source, source_type, uri, tags FROM objects
+          WHERE source = ? ORDER BY last_synced_at DESC LIMIT ?
+        `).all(source, limit);
+      } else if (cleanedQuery.length >= 2) {
+        const pattern = `%${escapeLike(cleanedQuery)}%`;
+        rows = sqlite.prepare(`
+          SELECT id, title, summary, source, source_type, uri, tags FROM objects
+          WHERE title LIKE ? OR summary LIKE ? OR tags LIKE ? OR source LIKE ? OR source_type LIKE ?
+          ORDER BY last_synced_at DESC LIMIT ?
+        `).all(pattern, pattern, pattern, pattern, pattern, limit);
+      } else {
+        rows = [];
+      }
+      logInfo("mcp", `search_data: "${query}"`, { source, resultCount: rows.length, ms: Date.now() - t0 });
+      return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_sources",
+    {},
+    async () => {
+      const sources = db.select().from(connectorConfigs).all();
+      const counts = sqlite.prepare(
+        `SELECT source, COUNT(*) as count FROM objects GROUP BY source`
+      ).all();
+      return {
+        content: [{ type: "text", text: JSON.stringify({ connectors: sources, objectCounts: counts }, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "fetch_content",
+    {
+      uri: z.string().describe("Object URI from search_data results")
+    },
+    async ({ uri }) => {
+      const obj = db.select().from(objects).where(eq(objects.uri, uri)).get();
+      if (!obj) {
+        return { content: [{ type: "text", text: `Object not found: ${uri}` }] };
+      }
+      const body = db.select().from(objectBodies).where(eq(objectBodies.objectId, obj.id)).get();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ ...obj, body: body?.content ?? null, contentType: body?.contentType ?? null }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "fetch_doc_map",
+    {
+      id: z.string().describe("Object ID from search_data results")
+    },
+    async ({ id }) => {
+      const row = sqlite.prepare(`SELECT doc_map, title FROM objects WHERE id = ?`).get(id);
+      if (!row) return { content: [{ type: "text", text: `Object not found: ${id}` }] };
+      if (!row.doc_map) {
+        return { content: [{ type: "text", text: `"${row.title}" has no document map (too small). Use fetch_content instead.` }] };
+      }
+      return { content: [{ type: "text", text: row.doc_map }] };
+    }
+  );
+  server.tool(
+    "fetch_chunk",
+    {
+      id: z.string().describe("Object ID"),
+      idx: z.number().describe("Chunk index (0-based, see fetch_doc_map output for available indices)")
+    },
+    async ({ id, idx }) => {
+      const chunk = sqlite.prepare(
+        `SELECT heading, content, tokens FROM object_chunks WHERE object_id = ? AND idx = ?`
+      ).get(id, idx);
+      if (!chunk) {
+        return { content: [{ type: "text", text: "Chunk not found. Call fetch_doc_map first to see available chunks." }] };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ heading: chunk.heading, tokens: chunk.tokens, content: chunk.content }, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "read_memory",
+    {
+      query: z.string().describe("Search keywords -- matches against title, content, and tags"),
+      limit: z.number().optional().default(10).describe("Max results")
+    },
+    async ({ query, limit }) => {
+      const pattern = `%${escapeLike(query)}%`;
+      const rows = db.select().from(memories).where(or(like(memories.title, pattern), like(memories.content, pattern), like(memories.tags, pattern))).orderBy(desc(memories.updatedAt)).limit(limit).all().filter((r) => r.scope === "personal" || process.env["JOWORK_MODE"] === "team");
+      const now = Date.now();
+      for (const row of rows) {
+        sqlite.prepare(`UPDATE memories SET last_used_at = ?, access_count = access_count + 1 WHERE id = ?`).run(now, row.id);
+      }
+      const results = rows.map((r) => ({
+        id: r.id,
+        title: r.title,
+        content: r.content,
+        tags: r.tags ? JSON.parse(r.tags) : [],
+        scope: r.scope,
+        pinned: r.pinned === 1
+      }));
+      if (results.length === 0) return { content: [{ type: "text", text: `No memories found for: ${query}` }] };
+      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+  server.tool(
+    "write_memory",
+    {
+      title: z.string().describe("Short descriptive title for the memory"),
+      content: z.string().describe("Memory content -- what to remember"),
+      tags: z.array(z.string()).optional().describe('Tags for categorization (e.g. ["decision", "preference"])'),
+      scope: z.enum(["personal", "team"]).optional().default("personal").describe("Scope")
+    },
+    async ({ title, content, tags, scope }) => {
+      const now = Date.now();
+      const id = createId("mem");
+      db.insert(memories).values({
+        id,
+        title,
+        content,
+        tags: JSON.stringify(tags ?? []),
+        scope,
+        pinned: 0,
+        source: "auto",
+        lastUsedAt: null,
+        createdAt: now,
+        updatedAt: now
+      }).run();
+      try {
+        const rowid = sqlite.prepare("SELECT rowid FROM memories WHERE id = ?").get(id);
+        if (rowid) {
+          sqlite.prepare(
+            "INSERT INTO memories_fts(rowid, title, content, tags) VALUES (?, ?, ?, ?)"
+          ).run(rowid.rowid, title, content, JSON.stringify(tags ?? []));
+        }
+      } catch {
+      }
+      try {
+        const count = sqlite.prepare("SELECT COUNT(*) AS c FROM memories").get();
+        if (count.c > MAX_MEMORIES) {
+          const excess = count.c - MAX_MEMORIES;
+          const toDelete = sqlite.prepare(
+            `SELECT id, rowid, title, content, tags FROM memories WHERE pinned = 0 ORDER BY updated_at ASC LIMIT ?`
+          ).all(excess);
+          for (const row of toDelete) {
+            try {
+              sqlite.prepare(
+                `INSERT INTO memories_fts(memories_fts, rowid, title, content, tags) VALUES ('delete', ?, ?, ?, ?)`
+              ).run(row.rowid, row.title, row.content, row.tags ?? "");
+            } catch {
+            }
+            sqlite.prepare("DELETE FROM memories WHERE id = ?").run(row.id);
+          }
+          logInfo("mcp", `write_memory: auto-truncated ${toDelete.length} old memories (cap: ${MAX_MEMORIES})`);
+        }
+      } catch {
+      }
+      logInfo("mcp", `write_memory: "${title}"`, { id, tags, scope });
+      return { content: [{ type: "text", text: `Memory saved: "${title}" (id: ${id})` }] };
+    }
+  );
+  server.tool(
+    "search_memory",
+    {
+      query: z.string().describe("Search query -- uses full-text search with time-weighted ranking"),
+      limit: z.number().optional().default(10).describe("Max results")
+    },
+    async ({ query, limit }) => {
+      const t0 = Date.now();
+      const escapedQuery = escapeFtsQuery(query);
+      let results = [];
+      try {
+        const ftsRows = sqlite.prepare(`
+          SELECT m.id, m.title, m.content, m.tags, m.scope, m.pinned,
+                 m.access_count, m.last_used_at, m.created_at, m.updated_at,
+                 rank
+          FROM memories_fts f
+          JOIN memories m ON m.rowid = f.rowid
+          WHERE memories_fts MATCH ?
+          ORDER BY rank
+          LIMIT ?
+        `).all(escapedQuery, limit);
+        if (ftsRows.length > 0) {
+          const now2 = Date.now();
+          const scored = ftsRows.map((r) => {
+            const recency = r.last_used_at ? Math.max(0, 1 - (now2 - r.last_used_at) / (30 * 24 * 60 * 60 * 1e3)) : 0;
+            const accessBoost = Math.min(r.access_count * 0.05, 0.5);
+            const pinnedBoost = r.pinned ? 0.3 : 0;
+            const score = -r.rank + recency * 2 + accessBoost + pinnedBoost;
+            return { ...r, score };
+          });
+          scored.sort((a, b) => b.score - a.score);
+          results = scored.map((r) => ({
+            id: r.id,
+            title: r.title,
+            content: r.content,
+            tags: r.tags ? JSON.parse(r.tags) : [],
+            scope: r.scope,
+            pinned: r.pinned === 1,
+            accessCount: r.access_count
+          }));
+        }
+      } catch {
+      }
+      if (results.length === 0) {
+        const pattern = `%${escapeLike(query)}%`;
+        const likeRows = db.select().from(memories).where(or(like(memories.title, pattern), like(memories.content, pattern), like(memories.tags, pattern))).orderBy(desc(memories.updatedAt)).limit(limit).all();
+        results = likeRows.map((r) => ({
+          id: r.id,
+          title: r.title,
+          content: r.content,
+          tags: r.tags ? JSON.parse(r.tags) : [],
+          scope: r.scope,
+          pinned: r.pinned === 1,
+          accessCount: r.accessCount
+        }));
+      }
+      const now = Date.now();
+      for (const r of results) {
+        sqlite.prepare("UPDATE memories SET last_used_at = ?, access_count = access_count + 1 WHERE id = ?").run(now, r.id);
+      }
+      logInfo("mcp", `search_memory: "${query}"`, { resultCount: results.length, ms: Date.now() - t0 });
+      if (results.length === 0) return { content: [{ type: "text", text: `No memories found for: ${query}` }] };
+      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_environment",
+    {},
+    async () => {
+      const now = /* @__PURE__ */ new Date();
+      const info = {
+        datetime: now.toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
+        timezone: "Asia/Shanghai",
+        platform: process.platform,
+        arch: process.arch,
+        nodeVersion: process.version,
+        uptime: `${Math.round(process.uptime() / 60)} min`,
+        memoryUsage: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB heap`
+      };
+      return { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] };
+    }
+  );
+  server.resource(
+    "connectors",
+    "jowork://connectors",
+    async (uri) => {
+      const sources = db.select().from(connectorConfigs).all();
+      const counts = sqlite.prepare(
+        `SELECT source, COUNT(*) as count FROM objects GROUP BY source`
+      ).all();
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify({ connectors: sources, objectCounts: counts }, null, 2)
+        }]
+      };
+    }
+  );
+  server.resource(
+    "memories",
+    "jowork://memories",
+    async (uri) => {
+      const mems = sqlite.prepare(
+        `SELECT id, title, tags, scope, pinned, access_count, updated_at FROM memories ORDER BY updated_at DESC LIMIT 50`
+      ).all();
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(mems, null, 2)
+        }]
+      };
+    }
+  );
+  server.resource(
+    "status",
+    "jowork://status",
+    async (uri) => {
+      const tables = ["objects", "memories", "connector_configs", "object_links"];
+      const counts = {};
+      for (const table of tables) {
+        try {
+          const row = sqlite.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+          counts[table] = row.count;
+        } catch {
+          counts[table] = 0;
+        }
+      }
+      let lastSync = null;
+      try {
+        const cursor = sqlite.prepare(
+          `SELECT connector_id, last_synced_at FROM sync_cursors ORDER BY last_synced_at DESC LIMIT 1`
+        ).get();
+        if (cursor) lastSync = { connector: cursor.connector_id, at: new Date(cursor.last_synced_at).toISOString() };
+      } catch {
+      }
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify({ tableCounts: counts, lastSync }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "get_goals",
+    {
+      status: z.string().optional().describe("Filter: active, paused, completed")
+    },
+    async ({ status }) => {
+      const goals = sqlite.prepare(
+        status ? `SELECT g.*, (SELECT COUNT(*) FROM signals WHERE goal_id = g.id) as signal_count FROM goals g WHERE g.status = ? ORDER BY g.created_at DESC` : `SELECT g.*, (SELECT COUNT(*) FROM signals WHERE goal_id = g.id) as signal_count FROM goals g ORDER BY g.created_at DESC`
+      ).all(...status ? [status] : []);
+      return { content: [{ type: "text", text: JSON.stringify(goals, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_metrics",
+    {
+      goal_id: z.string().optional().describe("Goal ID (shows all active if omitted)")
+    },
+    async ({ goal_id }) => {
+      const query = goal_id ? `SELECT s.*, m.threshold, m.comparison, m.current, m.met, g.title as goal_title
+           FROM signals s
+           JOIN goals g ON g.id = s.goal_id
+           LEFT JOIN measures m ON m.signal_id = s.id
+           WHERE s.goal_id = ? ORDER BY s.created_at` : `SELECT s.*, m.threshold, m.comparison, m.current, m.met, g.title as goal_title
+           FROM signals s
+           JOIN goals g ON g.id = s.goal_id AND g.status = 'active'
+           LEFT JOIN measures m ON m.signal_id = s.id
+           ORDER BY g.created_at DESC, s.created_at`;
+      const rows = sqlite.prepare(query).all(...goal_id ? [goal_id] : []);
+      return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+    }
+  );
+  server.tool(
+    "update_goal",
+    {
+      goal_id: z.string().describe("Goal ID"),
+      title: z.string().optional().describe("New title"),
+      description: z.string().optional().describe("New description"),
+      status: z.enum(["active", "paused", "completed"]).optional().describe("New status")
+    },
+    async ({ goal_id, title, description, status }) => {
+      const existing = sqlite.prepare("SELECT * FROM goals WHERE id = ?").get(goal_id);
+      if (!existing) return { content: [{ type: "text", text: `Goal not found: ${goal_id}` }] };
+      const now = Date.now();
+      const sets = ["updated_at = ?"];
+      const args = [now];
+      if (title) {
+        sets.push("title = ?");
+        args.push(title);
+      }
+      if (description) {
+        sets.push("description = ?");
+        args.push(description);
+      }
+      if (status) {
+        sets.push("status = ?");
+        args.push(status);
+      }
+      args.push(goal_id);
+      sqlite.prepare(`UPDATE goals SET ${sets.join(", ")} WHERE id = ?`).run(...args);
+      const updated = sqlite.prepare("SELECT * FROM goals WHERE id = ?").get(goal_id);
+      return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+    }
+  );
+  server.tool(
+    "push_to_channel",
+    {
+      channel: z.string().describe("Channel: feishu, slack, telegram"),
+      target: z.string().describe("Target ID (chat_id for feishu, channel for slack)"),
+      message: z.string().describe("Message content")
+    },
+    async ({ channel, target, message }) => {
+      if (channel === "feishu") {
+        try {
+          const credFile = join3(process.env["HOME"] ?? "", ".jowork", "credentials", "feishu.json");
+          if (!existsSync(credFile)) {
+            return { content: [{ type: "text", text: "Feishu not connected. Run `jowork connect feishu` first." }] };
+          }
+          const cred = JSON.parse(readFileSync(credFile, "utf-8"));
+          const tokenRes = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ app_id: cred.data.appId, app_secret: cred.data.appSecret })
+          });
+          const tokenData = await tokenRes.json();
+          if (tokenData.code !== 0) return { content: [{ type: "text", text: `Feishu auth failed: ${tokenData.code}` }] };
+          const msgRes = await fetch("https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=chat_id", {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${tokenData.tenant_access_token}` },
+            body: JSON.stringify({
+              receive_id: target,
+              msg_type: "text",
+              content: JSON.stringify({ text: message })
+            })
+          });
+          const msgData = await msgRes.json();
+          if (msgData.code !== 0) return { content: [{ type: "text", text: `Feishu send failed: ${msgData.code}` }] };
+          logInfo("mcp", `push_to_channel: feishu/${target}`, { length: message.length });
+          return { content: [{ type: "text", text: `\u2713 Message sent to Feishu chat ${target}` }] };
+        } catch (err) {
+          return { content: [{ type: "text", text: `Error: ${err}` }] };
+        }
+      }
+      return { content: [{ type: "text", text: `Channel "${channel}" not yet supported. Available: feishu` }] };
+    }
+  );
+  return server;
+}
+
+export {
+  logInfo,
+  logError,
+  joworkDir,
+  dbPath,
+  credentialsDir,
+  configPath,
+  logsDir,
+  createJoWorkMcpServer
+};