@meshxdata/fops 0.0.5 → 0.0.6

package/src/plugins/bundled/coda/index.js

@@ -0,0 +1,284 @@
+import { CodaClient } from "./client.js";
+import { loadCredentials, runCodaLogin } from "./auth.js";
+
+function getClient() {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error("Not authenticated with Coda. Run: fops coda login");
+    process.exit(1);
+  }
+  return new CodaClient(creds.access_token);
+}
+
+export default {
+  async register(api) {
+    const config = api.config;
+
+    // ── Register "fops coda" command group ──────────────────────────────
+    api.registerCommand((program) => {
+      const coda = program
+        .command("coda")
+        .description("Coda knowledge base");
+
+      // fops coda login
+      coda
+        .command("login")
+        .description("Authenticate with Coda (API token)")
+        .action(async () => {
+          const ok = await runCodaLogin();
+          if (!ok) process.exit(1);
+        });
+
+      // fops coda whoami
+      coda
+        .command("whoami")
+        .description("Show current Coda user")
+        .action(async () => {
+          try {
+            const client = getClient();
+            const user = await client.whoami();
+            console.log(`Logged in as: ${user.name} (${user.loginId})`);
+          } catch (err) {
+            console.error(err.message);
+            process.exit(1);
+          }
+        });
+
+      // fops coda docs [-q <query>]
+      coda
+        .command("docs")
+        .description("List or search Coda docs")
+        .option("-q, --query <query>", "Filter docs by name")
+        .action(async (opts) => {
+          try {
+            const client = getClient();
+            const result = await client.listDocs(opts.query);
+            const docs = result.items || [];
+
+            if (docs.length === 0) {
+              console.log(opts.query ? `No docs matching "${opts.query}"` : "No docs found");
+              return;
+            }
+
+            for (const doc of docs) {
+              console.log(`${doc.id}  ${doc.name}`);
+            }
+            console.log(`\n${docs.length} doc(s) found`);
+          } catch (err) {
+            console.error(err.message);
+            process.exit(1);
+          }
+        });
+
+      // fops coda search <query>
+      coda
+        .command("search <query>")
+        .description("Search docs and pages by name")
+        .action(async (query) => {
+          try {
+            const client = getClient();
+            const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+            const matches = (text) => words.every((w) => text.toLowerCase().includes(w));
+
+            // Fetch all docs (no query filter — API only searches doc names)
+            const result = await client.listDocs();
+            const docs = result.items || [];
+
+            let found = false;
+
+            for (const doc of docs) {
+              const docMatches = matches(doc.name);
+
+              let pages = [];
+              try {
+                const pageResult = await client.listPages(doc.id);
+                pages = pageResult.items || [];
+              } catch {
+                // skip if pages can't be listed
+              }
+
+              const matchingPages = pages.filter((p) => matches(p.name));
+
+              if (!docMatches && matchingPages.length === 0) continue;
+
+              found = true;
+              console.log(`\n── ${doc.name} (${doc.id}) ──`);
+
+              if (docMatches) {
+                // Doc name matches → show all pages
+                for (const page of pages) {
+                  const marker = matches(page.name) ? " ◀" : "";
+                  console.log(`  ${page.id}  ${page.name}${marker}`);
+                }
+              } else {
+                // Only page names match → show matching pages
+                for (const page of matchingPages) {
+                  console.log(`  ${page.id}  ${page.name} ◀`);
+                }
+              }
+            }
+
+            if (!found) {
+              console.log(`No docs or pages matching "${query}"`);
+            }
+          } catch (err) {
+            console.error(err.message);
+            process.exit(1);
+          }
+        });
+
+      // fops coda read <docId> [pageId]
+      coda
+        .command("read <docId> [pageId]")
+        .description("List pages or read a page as markdown")
+        .action(async (docId, pageId) => {
+          try {
+            const client = getClient();
+
+            if (!pageId) {
+              // List pages
+              const result = await client.listPages(docId);
+              const pages = result.items || [];
+
+              if (pages.length === 0) {
+                console.log("No pages in this doc");
+                return;
+              }
+
+              for (const page of pages) {
+                console.log(`${page.id}  ${page.name}`);
+              }
+              console.log(`\n${pages.length} page(s). Read one with: fops coda read ${docId} <pageId>`);
+              return;
+            }
+
+            // Export page as markdown
+            const content = await client.exportPage(docId, pageId);
+            console.log(typeof content === "string" ? content : JSON.stringify(content, null, 2));
+          } catch (err) {
+            console.error(err.message);
+            process.exit(1);
+          }
+        });
+
+      // fops coda tables <docId> [-t <tableId>] [-q <query>]
+      coda
+        .command("tables <docId>")
+        .description("List tables or query rows")
+        .option("-t, --table <tableId>", "Table ID to query rows from")
+        .option("-q, --query <query>", "Query to filter rows")
+        .action(async (docId, opts) => {
+          try {
+            const client = getClient();
+
+            if (!opts.table) {
+              // List tables
+              const result = await client.listTables(docId);
+              const tables = result.items || [];
+
+              if (tables.length === 0) {
+                console.log("No tables in this doc");
+                return;
+              }
+
+              for (const t of tables) {
+                console.log(`${t.id}  ${t.name}`);
+              }
+              console.log(`\n${tables.length} table(s). Query rows with: fops coda tables ${docId} -t <tableId>`);
+              return;
+            }
+
+            // List/query rows
+            const result = await client.listRows(docId, opts.table, opts.query);
+            const rows = result.items || [];
+
+            if (rows.length === 0) {
+              console.log(opts.query ? `No rows matching "${opts.query}"` : "No rows found");
+              return;
+            }
+
+            for (const row of rows) {
+              const values = row.values || {};
+              const cells = Object.entries(values)
+                .map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`)
+                .join(" | ");
+              console.log(`${row.id}  ${row.name || "(unnamed)"}  ${cells}`);
+            }
+            console.log(`\n${rows.length} row(s)`);
+          } catch (err) {
+            console.error(err.message);
+            process.exit(1);
+          }
+        });
+    });
+
+    // ── Register doctor check ───────────────────────────────────────────
+    api.registerDoctorCheck({
+      name: "coda",
+      fn: async (ok, warn) => {
+        const creds = loadCredentials();
+        if (!creds) {
+          warn("Coda", "Not authenticated. Run: fops coda login");
+          return;
+        }
+
+        try {
+          const client = new CodaClient(creds.access_token);
+          const user = await client.whoami();
+          ok("Coda", `connected as ${user.name}`);
+        } catch (err) {
+          warn("Coda", `Token may be expired: ${err.message}. Run: fops coda login`);
+        }
+      },
+    });
+
+    // ── Register RAG knowledge source ─────────────────────────────────
+    api.registerKnowledgeSource({
+      name: "Coda",
+      description: "Search Coda docs and pages by name",
+      async search(query) {
+        const creds = loadCredentials();
+        if (!creds) return [];
+
+        try {
+          const client = new CodaClient(creds.access_token);
+          const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+          const matches = (text) => words.every((w) => text.toLowerCase().includes(w));
+
+          const result = await client.listDocs();
+          const docs = result.items || [];
+          const results = [];
+
+          for (const doc of docs) {
+            const docMatches = matches(doc.name);
+
+            let pages = [];
+            try {
+              const pageResult = await client.listPages(doc.id);
+              pages = pageResult.items || [];
+            } catch {
+              continue;
+            }
+
+            for (const page of pages) {
+              const pageMatches = matches(page.name);
+              if (!docMatches && !pageMatches) continue;
+
+              const score = docMatches && pageMatches ? 1.0 : docMatches ? 0.7 : 0.5;
+              results.push({
+                title: `${doc.name} → ${page.name}`,
+                content: `Coda page "${page.name}" in doc "${doc.name}".\nRead with: fops coda read ${doc.id} ${page.id}`,
+                url: `https://coda.io/d/${doc.id}/_/${page.id}`,
+                score,
+              });
+            }
+          }
+
+          return results.sort((a, b) => b.score - a.score).slice(0, 10);
+        } catch {
+          return [];
+        }
+      },
+    });
+  },
+};

package/src/plugins/bundled/coda/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/src/plugins/bundled/coda/skills/coda/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: coda
+description: Search and read Coda knowledge base docs interactively
+---
+## Coda Knowledge Base
+
+Use `fops coda` commands to search and read internal documentation, runbooks, architecture decisions, and process docs stored in Coda.
+
+### When to Use
+
+- User asks about internal processes, onboarding, or "how we do X"
+- User needs a runbook, playbook, or architecture doc
+- User references a doc that might be in Coda
+- User asks "where is the doc for..." or "find the page about..."
+
+### Discovery Pattern
+
+Always follow: **search → list pages → read page**.
+
+1. Search for relevant docs by name:
+```bash
+fops coda docs -q "deployment"
+```
+
+2. Explore a doc's page structure:
+```bash
+fops coda read <docId>
+```
+
+3. Read a specific page as markdown:
+```bash
+fops coda read <docId> <pageId>
+```
+
+### Commands
+
+**List or search docs:**
+```bash
+fops coda docs
+fops coda docs -q "onboarding"
+```
+
+**Full-text search across docs (shows page structure):**
+```bash
+fops coda search "incident response"
+```
+
+**Read pages from a doc:**
+```bash
+fops coda read <docId>              # list all pages
+fops coda read <docId> <pageId>     # export page as markdown
+```
+
+**List tables or query rows:**
+```bash
+fops coda tables <docId>                          # list tables
+fops coda tables <docId> -t <tableId>             # list rows
+fops coda tables <docId> -t <tableId> -q "status:active"  # query rows
+```
+
+**Auth:**
+```bash
+fops coda login    # authenticate with Coda
+fops coda whoami   # check current auth
+```
+
+### Suggesting Commands
+
+Always suggest **2 commands** so the user can discover and then read:
+
+- Search + read: `fops coda docs -q "runbook"` + `fops coda read <docId>`
+- List + query: `fops coda tables <docId>` + `fops coda tables <docId> -t <tableId>`
+- Broad + narrow: `fops coda search "deploy"` + `fops coda read <docId> <pageId>`
+
+### Error Handling
+
+If a command returns an auth error, suggest:
+```bash
+fops coda login
+```
+
+Then retry the original command.

package/src/plugins/bundled/cursor/fops.plugin.json

@@ -0,0 +1,7 @@
+{
+  "id": "cursor",
+  "name": "Cursor IDE Integration",
+  "version": "0.1.0",
+  "description": "Bridge fops knowledge into Cursor AI via rules and edit commands",
+  "skills": ["skills/cursor"]
+}