@stndrds/cli 1.0.0-alpha.1

package/dist/bin.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import chalk3 from "chalk";
+import { Command } from "commander";
+
+// src/client.ts
+var ApiClientError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ApiClientError";
+  }
+};
+function buildUrl(base, path, params) {
+  const url = new URL(path, base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function createClient(config) {
+  const { apiUrl, apiKey } = config;
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  async function request(method, path, options) {
+    const url = buildUrl(apiUrl, path, options?.params);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: options?.body ? JSON.stringify(options.body) : void 0,
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (error) {
+      if (error instanceof TypeError || error instanceof DOMException && error.name === "TimeoutError") {
+        throw new ApiClientError(0, `Could not connect to ${apiUrl}. Is the server running?`);
+      }
+      throw error;
+    }
+    if (response.status === 204) {
+      return null;
+    }
+    const data = await response.json();
+    if (!response.ok) {
+      const message = data.message ?? `Request failed with status ${response.status}`;
+      throw new ApiClientError(response.status, message);
+    }
+    return data;
+  }
+  return {
+    get(path, params) {
+      return request("GET", path, { params });
+    },
+    post(path, body) {
+      return request("POST", path, { body });
+    },
+    patch(path, body) {
+      return request("PATCH", path, { body });
+    },
+    put(path, body) {
+      return request("PUT", path, { body });
+    },
+    delete(path) {
+      return request("DELETE", path);
+    }
+  };
+}
+
+// src/commands/auth.ts
+import chalk2 from "chalk";
+
+// src/output.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+var MAX_CELL_WIDTH = 50;
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function escapeCsvValue(value) {
+  if (value === null || value === void 0) return "";
+  const str = typeof value === "object" ? JSON.stringify(value) : String(value);
+  if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatCsv(items) {
+  if (items.length === 0) return "";
+  const headers = Object.keys(items[0]);
+  const headerLine = headers.join(",");
+  const rows = items.map((item) => headers.map((h) => escapeCsvValue(item[h])).join(","));
+  return [headerLine, ...rows].join("\n");
+}
+function formatTable(items) {
+  if (items.length === 0) return "No results.";
+  const headers = Object.keys(items[0]);
+  const table = new Table({
+    head: headers.map((h) => chalk.bold(h)),
+    style: { head: [], border: [] }
+  });
+  for (const item of items) {
+    const row = headers.map((h) => {
+      const val = item[h];
+      if (val === null || val === void 0) return "";
+      const str = typeof val === "object" ? JSON.stringify(val) : String(val);
+      return truncate(str, MAX_CELL_WIDTH);
+    });
+    table.push(row);
+  }
+  return table.toString();
+}
+function formatOutput(data, format) {
+  if (format === "json") {
+    process.stdout.write(`${formatJson(data)}
+`);
+    return;
+  }
+  const items = Array.isArray(data) ? data : [data];
+  if (format === "csv") {
+    process.stdout.write(`${formatCsv(items)}
+`);
+    return;
+  }
+  process.stdout.write(`${formatTable(items)}
+`);
+}
+
+// src/commands/auth.ts
+function getClientFromCommand(cmd) {
+  const root = cmd.optsWithGlobals();
+  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
+}
+function getFormat(cmd) {
+  return cmd.optsWithGlobals().format;
+}
+function registerAuthCommand(program2) {
+  const auth = program2.command("auth").description("Manage authentication and API keys");
+  auth.command("whoami").description("Show current configuration and validate API key").action(async (_opts, cmd) => {
+    const root = cmd.optsWithGlobals();
+    const client = getClientFromCommand(cmd);
+    const write = (msg) => process.stdout.write(`${msg}
+`);
+    write(chalk2.bold("Standards CLI Configuration"));
+    write(`  API URL:  ${root.apiUrl}`);
+    write(`  API Key:  ${root.apiKey ? `${root.apiKey.slice(0, 8)}...` : chalk2.red("not set")}`);
+    write("");
+    const keys = await client.get("/api-keys");
+    write(chalk2.green("\u2713 API key is valid"));
+    if (Array.isArray(keys) && keys.length > 0) {
+      write(`  Active keys: ${keys.length}`);
+    }
+  });
+  auth.command("create-key").description("Create a new API key").requiredOption("--name <name>", "name for the API key").option("--expires <date>", "expiration date (ISO 8601)").action(async (opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const body = {
+      name: opts.name,
+      permissions: []
+    };
+    if (opts.expires) body.expiresAt = opts.expires;
+    const result = await client.post("/api-keys", body);
+    formatOutput(result, getFormat(cmd));
+  });
+}
+
+// src/commands/documents.ts
+function getClientFromCommand2(cmd) {
+  const root = cmd.optsWithGlobals();
+  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
+}
+function getFormat2(cmd) {
+  return cmd.optsWithGlobals().format;
+}
+function registerDocumentsCommand(program2) {
+  const documents = program2.command("documents").description("Manage documents");
+  documents.command("list").description("List documents").option("--status <status>", "filter by processing status").option("--limit <n>", "max documents to return").option("--offset <n>", "number of documents to skip").action(async (opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const params = {};
+    if (opts.status) params.processingStatus = opts.status;
+    if (opts.limit) params.limit = opts.limit;
+    if (opts.offset) params.offset = opts.offset;
+    const result = await client.get("/documents", params);
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("get").description("Get a document by ID").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const result = await client.get(`/documents/${id}`);
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("create").description("Create a new document").requiredOption("--title <title>", "document title").option("--values <json>", "document values as JSON string").action(async (opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const body = { title: opts.title };
+    if (opts.values) body.values = JSON.parse(opts.values);
+    const result = await client.post("/documents", body);
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("update").description("Update a document").argument("<id>", "document ID").option("--title <title>", "new title").option("--values <json>", "new values as JSON string").action(async (id, opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const body = {};
+    if (opts.title) body.title = opts.title;
+    if (opts.values) body.values = JSON.parse(opts.values);
+    const result = await client.patch(`/documents/${id}`, body);
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("delete").description("Delete a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    await client.delete(`/documents/${id}`);
+    process.stdout.write(`Document ${id} deleted.
+`);
+  });
+  documents.command("preview").description("Get preview file for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const result = await client.get(`/documents/${id}/preview`);
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("slots").description("List slots for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const result = await client.get(`/documents/${id}/slots`);
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("add-slot").description("Add a file slot to a document").argument("<id>", "document ID").requiredOption("--slot-name <name>", "slot name").requiredOption("--file-id <fileId>", "file ID").action(async (id, opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    const result = await client.post(`/documents/${id}/slots`, {
+      slotName: opts.slotName,
+      fileId: opts.fileId
+    });
+    formatOutput(result, getFormat2(cmd));
+  });
+  documents.command("remove-slot").description("Remove a slot from a document").argument("<id>", "document ID").argument("<slotId>", "slot ID").action(async (id, slotId, _opts, cmd) => {
+    const client = getClientFromCommand2(cmd);
+    await client.delete(`/documents/${id}/slots/${slotId}`);
+    process.stdout.write(`Slot ${slotId} removed.
+`);
+  });
+}
+
+// src/commands/records.ts
+function getClientFromCommand3(cmd) {
+  const root = cmd.optsWithGlobals();
+  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
+}
+function getFormat3(cmd) {
+  return cmd.optsWithGlobals().format;
+}
+function parseSortFlag(sort) {
+  const [attribute, direction = "asc"] = sort.split(":");
+  return JSON.stringify([{ attribute, direction }]);
+}
+function registerRecordsCommand(program2) {
+  const records = program2.command("records").description("Manage records (CRUD + search)");
+  records.command("list").description("List records for an object").argument("<object>", "object name (e.g. contacts)").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").action(async (objectName, opts, cmd) => {
+    const client = getClientFromCommand3(cmd);
+    const params = {};
+    if (opts.limit) params.limit = opts.limit;
+    if (opts.offset) params.offset = opts.offset;
+    if (opts.sort) params.sorts = parseSortFlag(opts.sort);
+    if (opts.filter) params.filters = opts.filter;
+    const result = await client.get(`/records/${objectName}`, params);
+    formatOutput(result, getFormat3(cmd));
+  });
+  records.command("get").description("Get a record by ID").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
+    const client = getClientFromCommand3(cmd);
+    const result = await client.get(`/records/${objectName}/${id}`);
+    formatOutput(result, getFormat3(cmd));
+  });
+  records.command("create").description("Create a new record").argument("<object>", "object name").option("--data <json>", "record data as JSON string").action(async (objectName, opts, cmd) => {
+    const data = opts.data ? JSON.parse(opts.data) : {};
+    const client = getClientFromCommand3(cmd);
+    const result = await client.post(`/records/${objectName}`, data);
+    formatOutput(result, getFormat3(cmd));
+  });
+  records.command("update").description("Update a record").argument("<object>", "object name").argument("<id>", "record ID").option("--data <json>", "fields to update as JSON string").action(async (objectName, id, opts, cmd) => {
+    const data = opts.data ? JSON.parse(opts.data) : {};
+    const client = getClientFromCommand3(cmd);
+    const result = await client.put(`/records/${objectName}/${id}`, data);
+    formatOutput(result, getFormat3(cmd));
+  });
+  records.command("delete").description("Delete a record").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
+    const client = getClientFromCommand3(cmd);
+    await client.delete(`/records/${objectName}/${id}`);
+    process.stdout.write(`Record ${id} deleted.
+`);
+  });
+  records.command("search").description("Full-text search records").argument("<object>", "object name").requiredOption("--query <q>", "search query string").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").action(async (objectName, opts, cmd) => {
+    const client = getClientFromCommand3(cmd);
+    const params = { q: opts.query };
+    if (opts.limit) params.limit = opts.limit;
+    if (opts.offset) params.offset = opts.offset;
+    if (opts.sort) params.sorts = parseSortFlag(opts.sort);
+    if (opts.filter) params.filters = opts.filter;
+    const result = await client.get(`/records/${objectName}/search`, params);
+    formatOutput(result, getFormat3(cmd));
+  });
+}
+
+// src/commands/schema.ts
+function getClientFromCommand4(cmd) {
+  const root = cmd.optsWithGlobals();
+  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
+}
+function getFormat4(cmd) {
+  return cmd.optsWithGlobals().format;
+}
+function registerSchemaCommand(program2) {
+  const schema = program2.command("schema").description("Inspect schema objects and attributes");
+  schema.command("list").description("List all schema objects").action(async (_opts, cmd) => {
+    const client = getClientFromCommand4(cmd);
+    const result = await client.get("/schema/objects");
+    formatOutput(result, getFormat4(cmd));
+  });
+  schema.command("inspect").description("Inspect an object (attributes, types, views)").argument("<object>", "object name or ID").action(async (objectName, _opts, cmd) => {
+    const client = getClientFromCommand4(cmd);
+    const result = await client.get(`/schema/objects/${objectName}`);
+    formatOutput(result, getFormat4(cmd));
+  });
+}
+
+// src/bin.ts
+var program = new Command();
+program.name("standards").description("CLI to interact with Standards API").version("1.0.0-alpha.1").option("--format <format>", "output format (json, table, csv)", "json").option(
+  "--api-url <url>",
+  "API base URL",
+  process.env.STANDARDS_API_URL ?? "http://localhost:4100"
+).option("--api-key <key>", "API key for authentication", process.env.STANDARDS_API_KEY);
+registerRecordsCommand(program);
+registerSchemaCommand(program);
+registerDocumentsCommand(program);
+registerAuthCommand(program);
+program.hook("preAction", (_thisCommand, _actionCommand) => {
+  const opts = program.opts();
+  if (!opts.apiKey) {
+    console.error(
+      chalk3.red("\u2717 Error: No API key configured. Set STANDARDS_API_KEY or use --api-key")
+    );
+    process.exit(1);
+  }
+});
+program.parseAsync(process.argv).catch((error) => {
+  if (error instanceof ApiClientError) {
+    if (error.statusCode > 0) {
+      console.error(chalk3.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
+    } else {
+      console.error(chalk3.red(`\u2717 Error: ${error.message}`));
+    }
+  } else if (error instanceof Error) {
+    console.error(chalk3.red(`\u2717 Error: ${error.message}`));
+  }
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@stndrds/cli",
+  "version": "1.0.0-alpha.1",
+  "description": "CLI tool to interact with Standards API",
+  "type": "module",
+  "bin": {
+    "standards": "./dist/bin.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.9"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andyoucreate/standards.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "AndYouCreate",
+  "bugs": {
+    "url": "https://github.com/andyoucreate/standards/issues"
+  },
+  "homepage": "https://github.com/andyoucreate/standards#readme",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "biome check .",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}