lyzr-cortex-cli 0.1.2

package/README.md

@@ -0,0 +1,233 @@
+# Lyzr Cortex CLI
+
+Command-line tool for Cortex platform developers. Push documents, query the knowledge graph, share with users, and manage tool projects.
+
+## Installation
+
+```bash
+npm install -g lyzr-cortex-cli
+```
+
+## Configuration
+
+Set environment variables (or pass `--api-url`, `--api-key`, `--tool-id` to each command):
+
+```bash
+export CORTEX_API_URL=https://your-cortex-server.com
+export CORTEX_API_KEY=your-api-key
+export CORTEX_TOOL_ID=your-tool-id
+```
+
+---
+
+## API Commands
+
+These commands map directly to the Python (`lyzr-cortex-sdk`) and TypeScript (`lyzr-cortex-sdk`) SDK methods.
+
+| CLI Command | Python SDK | TypeScript SDK | HTTP Endpoint |
+|-------------|-----------|---------------|---------------|
+| `cortex push` | `client.push()` | `client.push()` | `POST /api/tools/documents` |
+| `cortex query` | `client.query()` | `client.query()` | `POST /api/tools/query` |
+| `cortex whoami` | `client.get_user_context()` | `client.getUserContext()` | `GET /api/tools/context/{email}` |
+| `cortex share` | `client.share_document()` | `client.shareDocument()` | `POST /api/tools/share-document-for-user` |
+| `cortex users` | `client.get_org_users()` | `client.getOrgUsers()` | `GET /api/tools/org-users-for-tool` |
+
+### `cortex push`
+
+Push a document to the Cortex Knowledge Graph.
+
+```bash
+# Push a transcript file
+cortex push transcript_123 --type meeting_transcript --file ./transcript.txt --name "Product Sync"
+
+# Push with personal scope
+cortex push doc_456 --type note --file ./note.md --scope personal
+
+# Push with team scope
+cortex push doc_789 --type report --file ./report.txt --scope team --teams "team_eng,team_product"
+
+# Push with metadata
+cortex push doc_abc --type doc --file ./doc.txt --metadata '{"author":"alice@co.com"}'
+```
+
+Options:
+- `<id>` - Unique document ID (required)
+- `-t, --type <type>` - Document type (required)
+- `-f, --file <path>` - File with document content (required)
+- `-n, --name <name>` - Display name
+- `-u, --url <url>` - External URL
+- `-s, --scope <scope>` - Access scope: `global`, `team`, or `personal` (default: `global`)
+- `--teams <ids>` - Comma-separated team IDs (for team scope)
+- `--metadata <json>` - JSON metadata object
+
+### `cortex query`
+
+Query the Cortex Knowledge Graph.
+
+```bash
+# Simple query
+cortex query "What decisions were made about Q1?"
+
+# Filter by document type
+cortex query "Latest meeting notes" --filters '{"type":["meeting_transcript"]}'
+
+# Limit to recent documents
+cortex query "Action items this week" --time-range 7
+
+# Get raw JSON output
+cortex query "Project status" --json
+```
+
+Options:
+- `<question>` - Natural language query (required)
+- `--filters <json>` - JSON filter object
+- `--time-range <days>` - Limit to recent N days
+- `--max-results <n>` - Maximum results (default: 10)
+- `--user-email <email>` - User email for access-scoped queries
+- `--json` - Output raw JSON
+
+### `cortex whoami`
+
+Get user context (teams, permissions, org info).
+
+```bash
+cortex whoami alice@company.com
+cortex whoami alice@company.com --json
+```
+
+Options:
+- `<email>` - User email address (required)
+- `--json` - Output raw JSON
+
+### `cortex share`
+
+Share a document with another user. The document appears in the recipient's "Shared with Me" at `/personal/shared`.
+
+```bash
+cortex share transcript_123 --from alice@co.com --to bob@co.com --name "Product Sync"
+```
+
+Options:
+- `<document-id>` - External ID of the document (required)
+- `--from <email>` - Sharer's email (required)
+- `--to <email>` - Recipient's email (required)
+- `-n, --name <name>` - Document display name
+- `-c, --content <text>` - Document content
+- `-u, --url <url>` - External URL
+- `--metadata <json>` - JSON metadata object
+
+### `cortex users`
+
+List organization users.
+
+```bash
+cortex users
+cortex users --exclude alice@co.com
+cortex users --json
+```
+
+Options:
+- `--exclude <email>` - Exclude an email from results
+- `--json` - Output raw JSON
+
+---
+
+## Project Management Commands
+
+### `cortex init`
+
+Initialize a new Cortex tool project.
+
+```bash
+cortex init
+cortex init --name my-tool --description "My awesome tool"
+cortex init -y  # Use defaults without prompts
+```
+
+Creates:
+- `cortex.yaml` - Tool manifest
+- `.env.example` - Environment variables template
+- Basic directory structure
+
+### `cortex validate`
+
+Validate your `cortex.yaml` manifest.
+
+```bash
+cortex validate
+cortex validate --file path/to/cortex.yaml
+```
+
+### `cortex dev`
+
+Start local development environment.
+
+```bash
+cortex dev
+cortex dev --port 8080
+```
+
+### `cortex deploy`
+
+Deploy your tool to Cortex platform.
+
+```bash
+cortex deploy
+cortex deploy --api-url https://api.cortex.ai --api-key your-key
+cortex deploy --dry-run
+```
+
+### `cortex status`
+
+Check tool registration and health status.
+
+```bash
+cortex status
+cortex status --api-url https://api.cortex.ai --api-key your-key
+```
+
+---
+
+## Access Scopes
+
+| Scope | Who Can See | Cortex UI Location |
+|-------|-------------|-------------------|
+| `global` | Everyone in organization | Organization knowledge base |
+| `team` | Specified team members | Team knowledge base |
+| `personal` | Only the creator | `/personal/transcripts` |
+| Shared via `cortex share` | Recipient | `/personal/shared` |
+
+## Manifest Format (cortex.yaml)
+
+```yaml
+name: my-tool
+display_name: My Tool
+description: A tool that does awesome things
+version: 1.0.0
+
+documents:
+  - my_document_type
+
+icon: puzzle
+ui:
+  embed_path: /
+  menu:
+    label: My Tool
+    position: tools
+
+build:
+  backend:
+    dockerfile: backend/Dockerfile
+    port: 8000
+    health_check: /health
+  frontend:
+    dockerfile: frontend/Dockerfile
+    port: 3000
+
+secrets:
+  - MY_API_KEY
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,753 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+var import_chalk12 = __toESM(require("chalk"));
+
+// src/commands/init.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_inquirer = __toESM(require("inquirer"));
+var import_ora = __toESM(require("ora"));
+
+// src/utils/manifest.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var yaml = __toESM(require("js-yaml"));
+function loadManifest(filePath = "cortex.yaml") {
+  const fullPath = path.resolve(process.cwd(), filePath);
+  if (!fs.existsSync(fullPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const manifest = yaml.load(content);
+    return manifest;
+  } catch (error) {
+    throw new Error(`Failed to parse ${filePath}: ${error}`);
+  }
+}
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest.name) {
+    errors.push({ field: "name", message: "Tool name is required" });
+  } else if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+    errors.push({
+      field: "name",
+      message: "Tool name must be lowercase alphanumeric with hyphens only"
+    });
+  }
+  if (!manifest.display_name) {
+    errors.push({ field: "display_name", message: "Display name is required" });
+  }
+  if (!manifest.version) {
+    errors.push({ field: "version", message: "Version is required" });
+  } else if (!/^\d+\.\d+\.\d+$/.test(manifest.version)) {
+    errors.push({
+      field: "version",
+      message: "Version must be semver format (e.g., 1.0.0)"
+    });
+  }
+  if (!manifest.documents || !Array.isArray(manifest.documents)) {
+    errors.push({
+      field: "documents",
+      message: "Documents array is required (list of document types this tool produces)"
+    });
+  }
+  if (manifest.build) {
+    if (manifest.build.backend) {
+      if (manifest.build.backend.port && typeof manifest.build.backend.port !== "number") {
+        errors.push({ field: "build.backend.port", message: "Port must be a number" });
+      }
+    }
+    if (manifest.build.frontend) {
+      if (manifest.build.frontend.port && typeof manifest.build.frontend.port !== "number") {
+        errors.push({ field: "build.frontend.port", message: "Port must be a number" });
+      }
+    }
+  }
+  return errors;
+}
+function createDefaultManifest(name, displayName, description) {
+  return {
+    name,
+    display_name: displayName,
+    description: description || `${displayName} tool for Cortex platform`,
+    version: "1.0.0",
+    documents: ["document"],
+    icon: "puzzle",
+    ui: {
+      embed_path: "/",
+      menu: {
+        label: displayName,
+        position: "tools"
+      }
+    },
+    build: {
+      backend: {
+        dockerfile: "backend/Dockerfile",
+        port: 8e3,
+        health_check: "/health"
+      },
+      frontend: {
+        dockerfile: "frontend/Dockerfile",
+        port: 3e3
+      }
+    },
+    secrets: []
+  };
+}
+function writeManifest(manifest, filePath = "cortex.yaml") {
+  const fullPath = path.resolve(process.cwd(), filePath);
+  const content = yaml.dump(manifest, {
+    indent: 2,
+    lineWidth: 100,
+    noRefs: true
+  });
+  fs.writeFileSync(fullPath, content, "utf-8");
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  console.log(import_chalk.default.cyan("\n  Cortex Tool Initializer\n"));
+  if (loadManifest()) {
+    console.log(import_chalk.default.yellow("  cortex.yaml already exists in this directory."));
+    const { overwrite } = await import_inquirer.default.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Overwrite existing cortex.yaml?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(import_chalk.default.gray("  Initialization cancelled."));
+      return;
+    }
+  }
+  let name;
+  let displayName;
+  let description;
+  let documentTypes;
+  if (options.yes) {
+    const dirName = path2.basename(process.cwd());
+    name = options.name || dirName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    displayName = name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    description = options.description || `${displayName} tool for Cortex`;
+    documentTypes = ["document"];
+  } else {
+    const answers = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Tool name (lowercase, hyphens only):",
+        default: options.name || path2.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+        validate: (input) => /^[a-z0-9-]+$/.test(input) || "Name must be lowercase alphanumeric with hyphens"
+      },
+      {
+        type: "input",
+        name: "displayName",
+        message: "Display name:",
+        default: (answers2) => answers2.name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Description:",
+        default: options.description
+      },
+      {
+        type: "input",
+        name: "documentTypes",
+        message: "Document types (comma-separated):",
+        default: "document"
+      }
+    ]);
+    name = answers.name;
+    displayName = answers.displayName;
+    description = answers.description;
+    documentTypes = answers.documentTypes.split(",").map((t) => t.trim());
+  }
+  const spinner = (0, import_ora.default)("Creating cortex.yaml...").start();
+  try {
+    const manifest = createDefaultManifest(name, displayName, description);
+    manifest.documents = documentTypes;
+    writeManifest(manifest);
+    spinner.succeed("Created cortex.yaml");
+    const dirs = ["backend", "frontend"];
+    for (const dir of dirs) {
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+        console.log(import_chalk.default.gray(`  Created ${dir}/`));
+      }
+    }
+    const envExample = `# Cortex Integration
+CORTEX_ENABLED=false
+CORTEX_API_URL=
+CORTEX_API_KEY=
+CORTEX_TOOL_ID=${name}
+CORTEX_JWT_PUBLIC_KEY=
+`;
+    if (!fs2.existsSync(".env.example")) {
+      fs2.writeFileSync(".env.example", envExample, "utf-8");
+      console.log(import_chalk.default.gray("  Created .env.example"));
+    }
+    console.log(import_chalk.default.green("\n  Tool initialized successfully!\n"));
+    console.log(import_chalk.default.gray("  Next steps:"));
+    console.log(import_chalk.default.gray("  1. Edit cortex.yaml with your tool configuration"));
+    console.log(import_chalk.default.gray("  2. Implement your backend and frontend"));
+    console.log(import_chalk.default.gray("  3. Run `cortex validate` to check your manifest"));
+    console.log(import_chalk.default.gray("  4. Run `cortex dev` to start local development\n"));
+  } catch (error) {
+    spinner.fail("Failed to create cortex.yaml");
+    console.error(import_chalk.default.red(`  Error: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/validate.ts
+var import_chalk2 = __toESM(require("chalk"));
+async function validateCommand(options) {
+  const filePath = options.file || "cortex.yaml";
+  console.log(import_chalk2.default.cyan(`
+  Validating ${filePath}...
+`));
+  const manifest = loadManifest(filePath);
+  if (!manifest) {
+    console.log(import_chalk2.default.red(`  Error: ${filePath} not found.`));
+    console.log(import_chalk2.default.gray("  Run `cortex init` to create a manifest.\n"));
+    process.exit(1);
+  }
+  const errors = validateManifest(manifest);
+  if (errors.length === 0) {
+    console.log(import_chalk2.default.green("  \u2713 Manifest is valid!\n"));
+    console.log(import_chalk2.default.gray("  Summary:"));
+    console.log(import_chalk2.default.gray(`    Name: ${manifest.name}`));
+    console.log(import_chalk2.default.gray(`    Display Name: ${manifest.display_name}`));
+    console.log(import_chalk2.default.gray(`    Version: ${manifest.version}`));
+    console.log(import_chalk2.default.gray(`    Documents: ${manifest.documents.join(", ")}`));
+    if (manifest.build?.backend) {
+      console.log(import_chalk2.default.gray(`    Backend Port: ${manifest.build.backend.port}`));
+    }
+    if (manifest.build?.frontend) {
+      console.log(import_chalk2.default.gray(`    Frontend Port: ${manifest.build.frontend.port}`));
+    }
+    console.log("");
+    process.exit(0);
+  } else {
+    console.log(import_chalk2.default.red(`  \u2717 Found ${errors.length} error(s):
+`));
+    for (const error of errors) {
+      console.log(import_chalk2.default.red(`    \u2022 ${error.field}: ${error.message}`));
+    }
+    console.log("");
+    process.exit(1);
+  }
+}
+
+// src/commands/dev.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+async function devCommand(options) {
+  console.log(import_chalk3.default.cyan("\n  Cortex Development Server\n"));
+  const manifest = loadManifest();
+  if (!manifest) {
+    console.log(import_chalk3.default.red("  Error: cortex.yaml not found."));
+    console.log(import_chalk3.default.gray("  Run `cortex init` first.\n"));
+    process.exit(1);
+  }
+  const errors = validateManifest(manifest);
+  if (errors.length > 0) {
+    console.log(import_chalk3.default.red("  Error: Invalid manifest. Run `cortex validate` for details.\n"));
+    process.exit(1);
+  }
+  const port = options.port || String(manifest.build?.backend?.port || 8e3);
+  console.log(import_chalk3.default.gray(`  Tool: ${manifest.display_name}`));
+  console.log(import_chalk3.default.gray(`  Version: ${manifest.version}`));
+  console.log("");
+  const spinner = (0, import_ora2.default)("Starting development environment...").start();
+  setTimeout(() => {
+    spinner.succeed("Development environment ready");
+    console.log(import_chalk3.default.green("\n  Local development server started!\n"));
+    console.log(import_chalk3.default.gray("  Environment variables set:"));
+    console.log(import_chalk3.default.gray(`    CORTEX_ENABLED=true`));
+    console.log(import_chalk3.default.gray(`    CORTEX_API_URL=http://localhost:${port}/api/tools`));
+    console.log(import_chalk3.default.gray(`    CORTEX_API_KEY=dev-key-${manifest.name}`));
+    console.log(import_chalk3.default.gray(`    CORTEX_TOOL_ID=${manifest.name}`));
+    console.log("");
+    console.log(import_chalk3.default.gray("  To start your tool:"));
+    console.log(import_chalk3.default.gray("    1. Set the environment variables above in your .env"));
+    console.log(import_chalk3.default.gray("    2. Start your backend and frontend services"));
+    console.log(import_chalk3.default.gray("    3. Your tool will connect to the local Cortex gateway"));
+    console.log("");
+    console.log(import_chalk3.default.cyan("  Press Ctrl+C to stop\n"));
+  }, 1e3);
+}
+
+// src/commands/deploy.ts
+var import_chalk4 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+var import_inquirer2 = __toESM(require("inquirer"));
+async function deployCommand(options) {
+  console.log(import_chalk4.default.cyan("\n  Cortex Tool Deployment\n"));
+  const manifest = loadManifest();
+  if (!manifest) {
+    console.log(import_chalk4.default.red("  Error: cortex.yaml not found."));
+    console.log(import_chalk4.default.gray("  Run `cortex init` first.\n"));
+    process.exit(1);
+  }
+  const errors = validateManifest(manifest);
+  if (errors.length > 0) {
+    console.log(import_chalk4.default.red("  Error: Invalid manifest. Run `cortex validate` for details.\n"));
+    process.exit(1);
+  }
+  let apiUrl = options.apiUrl || process.env.CORTEX_API_URL;
+  let apiKey = options.apiKey || process.env.CORTEX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.log(import_chalk4.default.yellow("  Cortex API credentials not provided.\n"));
+    const answers = await import_inquirer2.default.prompt([
+      {
+        type: "input",
+        name: "apiUrl",
+        message: "Cortex API URL:",
+        default: apiUrl || "https://api.cortex.ai",
+        when: !apiUrl
+      },
+      {
+        type: "password",
+        name: "apiKey",
+        message: "Cortex API Key:",
+        when: !apiKey
+      }
+    ]);
+    apiUrl = apiUrl || answers.apiUrl;
+    apiKey = apiKey || answers.apiKey;
+  }
+  if (!apiUrl || !apiKey) {
+    console.log(import_chalk4.default.red("  Error: API URL and API Key are required.\n"));
+    process.exit(1);
+  }
+  console.log(import_chalk4.default.gray(`  Tool: ${manifest.display_name} (${manifest.name})`));
+  console.log(import_chalk4.default.gray(`  Version: ${manifest.version}`));
+  console.log(import_chalk4.default.gray(`  Documents: ${manifest.documents.join(", ")}`));
+  console.log(import_chalk4.default.gray(`  Target: ${apiUrl}`));
+  console.log("");
+  if (options.dryRun) {
+    console.log(import_chalk4.default.yellow("  Dry run mode - no changes will be made.\n"));
+    console.log(import_chalk4.default.gray("  Would deploy:"));
+    console.log(import_chalk4.default.gray(`    \u2022 Register tool: ${manifest.name}`));
+    console.log(import_chalk4.default.gray(`    \u2022 Document types: ${manifest.documents.join(", ")}`));
+    if (manifest.build?.backend) {
+      console.log(import_chalk4.default.gray(`    \u2022 Backend: ${manifest.build.backend.dockerfile}`));
+    }
+    if (manifest.build?.frontend) {
+      console.log(import_chalk4.default.gray(`    \u2022 Frontend: ${manifest.build.frontend.dockerfile}`));
+    }
+    console.log("");
+    return;
+  }
+  const { confirm } = await import_inquirer2.default.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Deploy to Cortex platform?",
+      default: true
+    }
+  ]);
+  if (!confirm) {
+    console.log(import_chalk4.default.gray("  Deployment cancelled.\n"));
+    return;
+  }
+  const spinner = (0, import_ora3.default)("Deploying to Cortex...").start();
+  try {
+    await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+    spinner.succeed("Deployment complete!");
+    console.log(import_chalk4.default.green("\n  Tool deployed successfully!\n"));
+    console.log(import_chalk4.default.gray("  Your tool is now available in Cortex."));
+    console.log(import_chalk4.default.gray(`  Tool URL: ${apiUrl}/tools/${manifest.name}`));
+    console.log("");
+  } catch (error) {
+    spinner.fail("Deployment failed");
+    console.error(import_chalk4.default.red(`  Error: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/status.ts
+var import_chalk5 = __toESM(require("chalk"));
+var import_ora4 = __toESM(require("ora"));
+async function statusCommand(options) {
+  console.log(import_chalk5.default.cyan("\n  Cortex Tool Status\n"));
+  const manifest = loadManifest();
+  if (!manifest) {
+    console.log(import_chalk5.default.yellow("  No cortex.yaml found - showing general status.\n"));
+  } else {
+    console.log(import_chalk5.default.gray(`  Tool: ${manifest.display_name} (${manifest.name})`));
+    console.log(import_chalk5.default.gray(`  Version: ${manifest.version}`));
+    console.log("");
+  }
+  const apiUrl = options.apiUrl || process.env.CORTEX_API_URL;
+  const apiKey = options.apiKey || process.env.CORTEX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.log(import_chalk5.default.gray("  Local Status:"));
+    console.log(import_chalk5.default.gray("    cortex.yaml: " + (manifest ? import_chalk5.default.green("\u2713 Found") : import_chalk5.default.red("\u2717 Not found"))));
+    if (manifest) {
+      const hasBackend = manifest.build?.backend?.dockerfile && require("fs").existsSync(manifest.build.backend.dockerfile.split("/")[0]);
+      const hasFrontend = manifest.build?.frontend?.dockerfile && require("fs").existsSync(manifest.build.frontend.dockerfile.split("/")[0]);
+      console.log(
+        import_chalk5.default.gray("    Backend: " + (hasBackend ? import_chalk5.default.green("\u2713 Found") : import_chalk5.default.yellow("\u25CB Not found")))
+      );
+      console.log(
+        import_chalk5.default.gray("    Frontend: " + (hasFrontend ? import_chalk5.default.green("\u2713 Found") : import_chalk5.default.yellow("\u25CB Not found")))
+      );
+    }
+    console.log("");
+    console.log(import_chalk5.default.gray("  To check remote status, provide --api-url and --api-key"));
+    console.log(import_chalk5.default.gray("  or set CORTEX_API_URL and CORTEX_API_KEY environment variables.\n"));
+    return;
+  }
+  const spinner = (0, import_ora4.default)("Checking status...").start();
+  try {
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    spinner.stop();
+    console.log(import_chalk5.default.gray("  Remote Status:"));
+    console.log(import_chalk5.default.gray(`    API: ${apiUrl}`));
+    if (manifest) {
+      console.log(import_chalk5.default.gray(`    Registration: ${import_chalk5.default.green("\u2713 Registered")}`));
+      console.log(import_chalk5.default.gray(`    Status: ${import_chalk5.default.green("Active")}`));
+      console.log(import_chalk5.default.gray(`    Last Deployed: 2024-01-15 10:30:00`));
+      console.log(import_chalk5.default.gray(`    Documents Pushed: 1,234`));
+      console.log(import_chalk5.default.gray(`    Queries Served: 5,678`));
+    } else {
+      console.log(import_chalk5.default.gray(`    Connection: ${import_chalk5.default.green("\u2713 Connected")}`));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to check status");
+    console.error(import_chalk5.default.red(`  Error: ${error}`));
+    console.log("");
+    process.exit(1);
+  }
+}
+
+// src/commands/push.ts
+var import_chalk7 = __toESM(require("chalk"));
+var import_ora5 = __toESM(require("ora"));
+var fs3 = __toESM(require("fs"));
+
+// src/utils/api.ts
+var import_chalk6 = __toESM(require("chalk"));
+function resolveConfig(options) {
+  const apiUrl = options.apiUrl || process.env.CORTEX_API_URL;
+  const apiKey = options.apiKey || process.env.CORTEX_API_KEY;
+  const toolId = options.toolId || process.env.CORTEX_TOOL_ID || "";
+  if (!apiUrl || !apiKey) {
+    console.log(import_chalk6.default.red("\n  Error: Missing API credentials.\n"));
+    console.log(import_chalk6.default.gray("  Provide --api-url and --api-key options, or set environment variables:"));
+    console.log(import_chalk6.default.gray("    CORTEX_API_URL=https://your-cortex-server.com"));
+    console.log(import_chalk6.default.gray("    CORTEX_API_KEY=your-api-key"));
+    console.log(import_chalk6.default.gray("    CORTEX_TOOL_ID=your-tool-id\n"));
+    return null;
+  }
+  return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey, toolId };
+}
+async function apiRequest(config, method, path3, body) {
+  const url = `${config.apiUrl}${path3}`;
+  const headers = {
+    "Content-Type": "application/json",
+    "X-API-Key": config.apiKey
+  };
+  if (config.toolId) {
+    headers["X-Cortex-Tool-ID"] = config.toolId;
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API error (${response.status}): ${errorText}`);
+  }
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+
+// src/commands/push.ts
+async function pushCommand(id, options) {
+  const config = resolveConfig(options);
+  if (!config) process.exit(1);
+  let content;
+  if (options.file) {
+    if (!fs3.existsSync(options.file)) {
+      console.log(import_chalk7.default.red(`
+  Error: File not found: ${options.file}
+`));
+      process.exit(1);
+    }
+    content = fs3.readFileSync(options.file, "utf-8");
+  } else {
+    console.log(import_chalk7.default.red("\n  Error: --file <path> is required to provide document content.\n"));
+    process.exit(1);
+  }
+  let metadata;
+  if (options.metadata) {
+    try {
+      metadata = JSON.parse(options.metadata);
+    } catch {
+      console.log(import_chalk7.default.red("\n  Error: --metadata must be valid JSON.\n"));
+      process.exit(1);
+    }
+  }
+  const teamIds = options.teams ? options.teams.split(",").map((t) => t.trim()) : void 0;
+  const spinner = (0, import_ora5.default)("Pushing document to Cortex...").start();
+  try {
+    const result = await apiRequest(
+      config,
+      "POST",
+      "/api/tools/documents",
+      {
+        external_id: id,
+        document_type: options.type,
+        content,
+        name: options.name || id,
+        external_url: options.url,
+        access_scope: options.scope || "global",
+        scope_team_ids: teamIds,
+        metadata
+      }
+    );
+    spinner.succeed("Document pushed successfully");
+    console.log(import_chalk7.default.gray(`
+  ID: ${result.id || id}`));
+    console.log(import_chalk7.default.gray(`  Status: ${result.status || "ok"}`));
+    console.log(import_chalk7.default.gray(`  Type: ${options.type}`));
+    console.log(import_chalk7.default.gray(`  Scope: ${options.scope || "global"}
+`));
+  } catch (error) {
+    spinner.fail("Failed to push document");
+    console.error(import_chalk7.default.red(`  ${error}
+`));
+    process.exit(1);
+  }
+}
+
+// src/commands/query.ts
+var import_chalk8 = __toESM(require("chalk"));
+var import_ora6 = __toESM(require("ora"));
+async function queryCommand(question, options) {
+  const config = resolveConfig(options);
+  if (!config) process.exit(1);
+  let filters;
+  if (options.filters) {
+    try {
+      filters = JSON.parse(options.filters);
+    } catch {
+      console.log(import_chalk8.default.red("\n  Error: --filters must be valid JSON.\n"));
+      process.exit(1);
+    }
+  }
+  const spinner = (0, import_ora6.default)("Querying Cortex...").start();
+  try {
+    const result = await apiRequest(config, "POST", "/api/tools/query", {
+      query: question,
+      filters,
+      time_range_days: options.timeRange ? parseInt(options.timeRange, 10) : void 0,
+      max_results: options.maxResults ? parseInt(options.maxResults, 10) : 10,
+      user_email: options.userEmail
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk8.default.cyan("\n  Answer:\n"));
+    console.log(`  ${result.answer}
+`);
+    if (result.sources && result.sources.length > 0) {
+      console.log(import_chalk8.default.gray(`  Sources (${result.sources.length}):`));
+      for (const source of result.sources) {
+        console.log(import_chalk8.default.gray(`    \u2022 [${source.type}] ${source.name}`));
+        if (source.excerpt) {
+          console.log(import_chalk8.default.gray(`      ${source.excerpt.substring(0, 120)}...`));
+        }
+      }
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Query failed");
+    console.error(import_chalk8.default.red(`  ${error}
+`));
+    process.exit(1);
+  }
+}
+
+// src/commands/whoami.ts
+var import_chalk9 = __toESM(require("chalk"));
+var import_ora7 = __toESM(require("ora"));
+async function whoamiCommand(email, options) {
+  const config = resolveConfig(options);
+  if (!config) process.exit(1);
+  const spinner = (0, import_ora7.default)(`Looking up ${email}...`).start();
+  try {
+    const user = await apiRequest(config, "GET", `/api/tools/context/${encodeURIComponent(email)}`);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(user, null, 2));
+      return;
+    }
+    console.log(import_chalk9.default.cyan("\n  User Context:\n"));
+    console.log(import_chalk9.default.gray(`  Email:  ${user.email}`));
+    if (user.full_name) console.log(import_chalk9.default.gray(`  Name:   ${user.full_name}`));
+    if (user.org_name) console.log(import_chalk9.default.gray(`  Org:    ${user.org_name}`));
+    if (user.role) console.log(import_chalk9.default.gray(`  Role:   ${user.role}`));
+    if (user.teams && user.teams.length > 0) {
+      console.log(import_chalk9.default.gray(`  Teams:`));
+      for (const team of user.teams) {
+        console.log(import_chalk9.default.gray(`    \u2022 ${team.name} (${team.id})`));
+      }
+    }
+    if (user.permissions && user.permissions.length > 0) {
+      console.log(import_chalk9.default.gray(`  Permissions: ${user.permissions.join(", ")}`));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to get user context");
+    if (String(error).includes("404")) {
+      console.log(import_chalk9.default.yellow(`  User ${email} not found in Cortex.
+`));
+    } else {
+      console.error(import_chalk9.default.red(`  ${error}
+`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/share.ts
+var import_chalk10 = __toESM(require("chalk"));
+var import_ora8 = __toESM(require("ora"));
+async function shareCommand(documentId, options) {
+  const config = resolveConfig(options);
+  if (!config) process.exit(1);
+  if (!options.from || !options.to) {
+    console.log(import_chalk10.default.red("\n  Error: --from and --to email addresses are required.\n"));
+    console.log(import_chalk10.default.gray("  Usage: cortex share <document-id> --from alice@co.com --to bob@co.com\n"));
+    process.exit(1);
+  }
+  let metadata;
+  if (options.metadata) {
+    try {
+      metadata = JSON.parse(options.metadata);
+    } catch {
+      console.log(import_chalk10.default.red("\n  Error: --metadata must be valid JSON.\n"));
+      process.exit(1);
+    }
+  }
+  const spinner = (0, import_ora8.default)(`Sharing document with ${options.to}...`).start();
+  try {
+    const result = await apiRequest(
+      config,
+      "POST",
+      "/api/tools/share-document-for-user",
+      {
+        document_external_id: documentId,
+        shared_by_email: options.from,
+        shared_with_email: options.to,
+        document_name: options.name,
+        content: options.content,
+        external_url: options.url,
+        metadata
+      }
+    );
+    spinner.succeed("Document shared successfully");
+    console.log(import_chalk10.default.gray(`
+  Document: ${documentId}`));
+    console.log(import_chalk10.default.gray(`  From: ${options.from}`));
+    console.log(import_chalk10.default.gray(`  To: ${options.to}`));
+    if (result.id) console.log(import_chalk10.default.gray(`  Share ID: ${result.id}`));
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to share document");
+    console.error(import_chalk10.default.red(`  ${error}
+`));
+    process.exit(1);
+  }
+}
+
+// src/commands/users.ts
+var import_chalk11 = __toESM(require("chalk"));
+var import_ora9 = __toESM(require("ora"));
+async function usersCommand(options) {
+  const config = resolveConfig(options);
+  if (!config) process.exit(1);
+  const spinner = (0, import_ora9.default)("Fetching organization users...").start();
+  try {
+    const params = options.exclude ? `?exclude_email=${encodeURIComponent(options.exclude)}` : "";
+    const users = await apiRequest(config, "GET", `/api/tools/org-users-for-tool${params}`);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(users, null, 2));
+      return;
+    }
+    console.log(import_chalk11.default.cyan(`
+  Organization Users (${users.length}):
+`));
+    if (users.length === 0) {
+      console.log(import_chalk11.default.gray("  No users found.\n"));
+      return;
+    }
+    for (const user of users) {
+      console.log(import_chalk11.default.gray(`  \u2022 ${user.full_name || "Unknown"} <${user.email}>`));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to fetch users");
+    console.error(import_chalk11.default.red(`  ${error}
+`));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("cortex").description("CLI tool for Cortex platform developers").version("0.1.2");
+program.command("init").description("Initialize a new Cortex tool project").option("-n, --name <name>", "Tool name").option("-d, --description <desc>", "Tool description").option("-y, --yes", "Skip prompts and use defaults").action(initCommand);
+program.command("validate").description("Validate cortex.yaml manifest").option("-f, --file <path>", "Path to manifest file", "cortex.yaml").action(validateCommand);
+program.command("dev").description("Start local development environment").option("-p, --port <port>", "API port", "8000").option("--no-browser", "Do not open browser").action(devCommand);
+program.command("deploy").description("Deploy tool to Cortex platform").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").option("--dry-run", "Show what would be deployed without deploying").action(deployCommand);
+program.command("status").description("Check tool registration status").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").action(statusCommand);
+program.command("push <id>").description("Push a document to Cortex Knowledge Graph").requiredOption("-t, --type <type>", "Document type (e.g., meeting_transcript)").requiredOption("-f, --file <path>", "File containing document content").option("-n, --name <name>", "Display name for the document").option("-u, --url <url>", "External URL for the document").option("-s, --scope <scope>", "Access scope: global, team, or personal", "global").option("--teams <ids>", "Comma-separated team IDs (for team scope)").option("--metadata <json>", "JSON metadata object").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").option("--tool-id <id>", "Cortex Tool ID").action(pushCommand);
+program.command("query <question>").description("Query the Cortex Knowledge Graph").option("--filters <json>", `JSON filter object (e.g., '{"type":["meeting_transcript"]}')`).option("--time-range <days>", "Limit to recent N days").option("--max-results <n>", "Maximum results", "10").option("--user-email <email>", "User email for access-scoped queries").option("--json", "Output raw JSON").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").option("--tool-id <id>", "Cortex Tool ID").action(queryCommand);
+program.command("whoami <email>").description("Get user context from Cortex").option("--json", "Output raw JSON").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").option("--tool-id <id>", "Cortex Tool ID").action(whoamiCommand);
+program.command("share <document-id>").description("Share a document with another user").requiredOption("--from <email>", "Sharer email address").requiredOption("--to <email>", "Recipient email address").option("-n, --name <name>", "Document display name").option("-c, --content <text>", "Document content").option("-u, --url <url>", "External URL").option("--metadata <json>", "JSON metadata object").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").option("--tool-id <id>", "Cortex Tool ID").action(shareCommand);
+program.command("users").description("List organization users").option("--exclude <email>", "Exclude email from results").option("--json", "Output raw JSON").option("--api-url <url>", "Cortex API URL").option("--api-key <key>", "Cortex API key").option("--tool-id <id>", "Cortex Tool ID").action(usersCommand);
+program.parse();
+if (!process.argv.slice(2).length) {
+  console.log(import_chalk12.default.cyan("\n  Cortex CLI - Build tools for Cortex platform\n"));
+  program.help();
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "lyzr-cortex-cli",
+  "version": "0.1.2",
+  "description": "CLI tool for Cortex platform developers - push, query, share documents and manage tools",
+  "author": "Cortex Lyzr AI",
+  "email": "krish@lyzr.ai",
+  "license": "MIT",
+  "bin": {
+    "cortex": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts --clean",
+    "dev": "tsup src/index.ts --format cjs --dts --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.6",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "keywords": [
+    "cortex",
+    "cli",
+    "tools",
+    "sdk",
+    "knowledge-graph",
+    "rag",
+    "lyzr"
+  ],
+  "homepage": "https://cortex.lyzr.app/docs",
+  "repository": {
+    "type": "git"
+  },
+  "bugs": {
+  }
+}