x1pm 0.0.1

package/dist/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const USAGE = `Usage: x1pm <command> [options]
+
+Commands:
+  ls              List files and directories
+  read            Read a file
+  write           Create a new file
+  edit            Edit a file (atomic string replacement)
+  multi-edit      Batch edit multiple files
+  glob            Find files by pattern
+  grep            Search file contents
+  health          Health check
+
+Options:
+  --key <key>         API key (or X1PM_API_KEY env var)
+  --server <url>      Server URL (default: https://x1pm.com, or X1PM_SERVER env var)
+
+Command options:
+  --path <path>       File or directory path
+  --content <text>    File content (for write; use "-" to read from stdin)
+  --old-str <text>    String to find (for edit; use "-" to read from stdin)
+  --new-str <text>    Replacement string (for edit; use "-" to read from stdin)
+  --pattern <pat>     Search or glob pattern
+  --output-mode <m>   Grep output mode: content | files_with_matches | count
+  --offset <n>        Line offset (for read)
+  --limit <n>         Line limit (for read)
+  --edits <json>      JSON array of edits (for multi-edit)`;
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const command = args[0] ?? "";
+    const flags = {};
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--") && i + 1 < args.length) {
+            flags[arg.slice(2)] = args[++i];
+        }
+    }
+    return { command, flags };
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+async function resolveValue(value) {
+    if (value === "-")
+        return readStdin();
+    return value;
+}
+async function callApi(server, apiKey, fn, body) {
+    const url = `${server}/api/${fn}`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        process.stderr.write(`Error (${res.status}): ${text}\n`);
+        process.exit(1);
+    }
+    return res.json();
+}
+async function main() {
+    const { command, flags } = parseArgs(process.argv);
+    if (!command || command === "help" || command === "--help" || command === "-h") {
+        console.log(USAGE);
+        process.exit(0);
+    }
+    const apiKey = flags["key"] ?? process.env.X1PM_API_KEY;
+    const server = (flags["server"] ?? process.env.X1PM_SERVER ?? "https://x1pm.com").replace(/\/$/, "");
+    if (!apiKey && command !== "health") {
+        process.stderr.write("Error: API key required. Set X1PM_API_KEY env var or pass --key.\n");
+        process.exit(1);
+    }
+    let result;
+    switch (command) {
+        case "health":
+            result = await callApi(server, apiKey ?? "", "healthCheck", {});
+            break;
+        case "ls":
+            result = await callApi(server, apiKey, "ls", {
+                path: flags["path"] ?? null,
+            });
+            break;
+        case "read":
+            if (!flags["path"]) {
+                process.stderr.write("Error: --path is required for read\n");
+                process.exit(1);
+            }
+            result = await callApi(server, apiKey, "read", {
+                path: flags["path"],
+                offset: flags["offset"] ? parseInt(flags["offset"], 10) : null,
+                limit: flags["limit"] ? parseInt(flags["limit"], 10) : null,
+            });
+            break;
+        case "write": {
+            if (!flags["path"]) {
+                process.stderr.write("Error: --path is required for write\n");
+                process.exit(1);
+            }
+            const content = await resolveValue(flags["content"]);
+            if (content === undefined) {
+                process.stderr.write("Error: --content is required for write\n");
+                process.exit(1);
+            }
+            result = await callApi(server, apiKey, "write", {
+                path: flags["path"],
+                content,
+            });
+            break;
+        }
+        case "edit": {
+            if (!flags["path"]) {
+                process.stderr.write("Error: --path is required for edit\n");
+                process.exit(1);
+            }
+            const oldStr = await resolveValue(flags["old-str"]);
+            const newStr = await resolveValue(flags["new-str"]);
+            if (oldStr === undefined || newStr === undefined) {
+                process.stderr.write("Error: --old-str and --new-str are required for edit\n");
+                process.exit(1);
+            }
+            result = await callApi(server, apiKey, "edit", {
+                path: flags["path"],
+                old_str: oldStr,
+                new_str: newStr,
+            });
+            break;
+        }
+        case "multi-edit": {
+            const editsJson = flags["edits"];
+            if (!editsJson) {
+                process.stderr.write("Error: --edits is required for multi-edit\n");
+                process.exit(1);
+            }
+            let edits;
+            try {
+                edits = JSON.parse(editsJson);
+            }
+            catch {
+                process.stderr.write("Error: --edits must be valid JSON\n");
+                process.exit(1);
+            }
+            result = await callApi(server, apiKey, "multiEdit", { edits });
+            break;
+        }
+        case "glob":
+            if (!flags["pattern"]) {
+                process.stderr.write("Error: --pattern is required for glob\n");
+                process.exit(1);
+            }
+            result = await callApi(server, apiKey, "glob", {
+                pattern: flags["pattern"],
+                path: flags["path"] ?? null,
+            });
+            break;
+        case "grep":
+            if (!flags["pattern"]) {
+                process.stderr.write("Error: --pattern is required for grep\n");
+                process.exit(1);
+            }
+            result = await callApi(server, apiKey, "grep", {
+                pattern: flags["pattern"],
+                path: flags["path"] ?? null,
+                output_mode: flags["output-mode"] ?? null,
+            });
+            break;
+        default:
+            process.stderr.write(`Unknown command: ${command}\n\n`);
+            console.log(USAGE);
+            process.exit(1);
+    }
+    console.log(JSON.stringify(result, null, 2));
+}
+main().catch((err) => {
+    process.stderr.write(`Error: ${err.message}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "x1pm",
+  "version": "0.0.1",
+  "description": "CLI for x1pm - shared workspace for human-AI teams",
+  "bin": {
+    "x1pm": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "agent",
+    "workspace",
+    "claude-skill",
+    "collaboration"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vanna-ai/x1pm.git",
+    "directory": "cli"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}