artisense 0.1.0

package/dist/index.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+
+// src/commands/skill.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve as resolve2, dirname } from "node:path";
+
+// src/config.ts
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+var DEFAULT_BASE_URL = "https://artisense.app";
+function getApiKey() {
+  const key = process.env.ARTISENSE_API_KEY;
+  if (!key) {
+    console.error(`Error: ARTISENSE_API_KEY is not set.
+Set it in your .env or shell environment.`);
+    process.exit(1);
+  }
+  return key;
+}
+async function getBaseUrl() {
+  if (process.env.ARTISENSE_BASE_URL) {
+    return process.env.ARTISENSE_BASE_URL.replace(/\/$/, "");
+  }
+  try {
+    const skillPath = resolve(process.cwd(), "SKILL.md");
+    const content = await readFile(skillPath, "utf-8");
+    const match = content.match(/^Base URL:\s*(.+)$/m);
+    if (match) {
+      return match[1].trim().replace(/\/$/, "");
+    }
+  } catch {}
+  return DEFAULT_BASE_URL;
+}
+
+// src/commands/skill.ts
+var TARGETS = {
+  claude: {
+    path: ".claude/commands/artisense.md",
+    label: "Claude Code",
+    wrap: (c) => c
+  },
+  cursor: {
+    path: ".cursor/rules/artisense.mdc",
+    label: "Cursor",
+    wrap: (c) => `---
+description: Artisense API skill for managing documents
+globs:
+alwaysApply: false
+---
+
+${c}`
+  },
+  copilot: {
+    path: ".github/copilot-instructions.md",
+    label: "GitHub Copilot",
+    wrap: (c) => c
+  }
+};
+var ALL_TARGET_KEYS = Object.keys(TARGETS);
+async function skillCommand(args) {
+  const { baseUrl, targetKeys } = parseArgs(args);
+  const endpoint = `${baseUrl}/api/v1/skill`;
+  console.log(`Downloading SKILL.md from ${endpoint} ...`);
+  const res = await fetch(endpoint);
+  if (!res.ok) {
+    console.error(`Error: Failed to download (HTTP ${res.status})`);
+    process.exit(1);
+  }
+  const content = await res.text();
+  const cwd = process.cwd();
+  const rootPath = resolve2(cwd, "SKILL.md");
+  await writeFile(rootPath, content, "utf-8");
+  console.log(`  Project root: ${rootPath}`);
+  for (const key of targetKeys) {
+    const target = TARGETS[key];
+    const fullPath = resolve2(cwd, target.path);
+    try {
+      await mkdir(dirname(fullPath), { recursive: true });
+      await writeFile(fullPath, target.wrap(content), "utf-8");
+      console.log(`  ${target.label}: ${fullPath}`);
+    } catch {
+      console.warn(`  ${target.label}: skipped (cannot write)`);
+    }
+  }
+  console.log(`
+Next: set your API key:
+  ARTISENSE_API_KEY="ask_..."
+`);
+}
+function parseArgs(args) {
+  let baseUrl = DEFAULT_BASE_URL;
+  const targetKeys = [];
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") {
+      printUsage();
+      process.exit(0);
+    } else if (arg === "--all") {
+      targetKeys.push(...ALL_TARGET_KEYS);
+    } else if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (key in TARGETS) {
+        targetKeys.push(key);
+      } else {
+        console.error(`Unknown option: ${arg}`);
+        printUsage();
+        process.exit(1);
+      }
+    } else {
+      baseUrl = arg.replace(/\/$/, "");
+    }
+  }
+  return { baseUrl, targetKeys };
+}
+function printUsage() {
+  console.log(`
+Usage: artisense skill [options]
+
+Downloads SKILL.md to your project root.
+
+Options:
+  --claude    Also save to .claude/commands/artisense.md
+  --cursor    Also save to .cursor/rules/artisense.mdc
+  --copilot   Also save to .github/copilot-instructions.md
+  --all       All of the above
+
+Examples:
+  artisense skill
+  artisense skill --claude
+  artisense skill --claude --cursor
+  artisense skill --all
+`);
+}
+
+// src/api.ts
+async function request(baseUrl, path, apiKey, options = {}) {
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: options.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      ...options.body ? { "Content-Type": "application/json" } : {}
+    },
+    body: options.body ? JSON.stringify(options.body) : undefined
+  });
+  const json = await res.json();
+  if (!res.ok) {
+    const message = json.error ?? `HTTP ${res.status}`;
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+  return json;
+}
+
+// src/commands/documents.ts
+async function documentsCommand(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list":
+    case "ls":
+    case undefined:
+      return listDocuments();
+    case "get":
+    case "read":
+      return getDocument(args[1]);
+    case "create":
+      return createDocument(args.slice(1));
+    case "update":
+      return updateDocument(args[1], args.slice(2));
+    case "delete":
+    case "rm":
+      return deleteDocument(args[1]);
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      printUsage2();
+      process.exit(1);
+  }
+}
+async function listDocuments() {
+  const [baseUrl, apiKey] = await Promise.all([getBaseUrl(), getApiKey()]);
+  const result = await request(baseUrl, "/api/v1/documents", apiKey);
+  if (result.data.length === 0) {
+    console.log("No documents found.");
+    return;
+  }
+  for (const doc of result.data) {
+    const title = doc.title || "(Untitled)";
+    console.log(`${doc.id}  ${title}  [${doc.type}]  ${doc.updatedAt}`);
+  }
+}
+async function getDocument(id) {
+  if (!id) {
+    console.error("Usage: artisense docs get <document-id>");
+    process.exit(1);
+  }
+  const [baseUrl, apiKey] = await Promise.all([getBaseUrl(), getApiKey()]);
+  const result = await request(baseUrl, `/api/v1/documents/${id}`, apiKey);
+  console.log(JSON.stringify(result.data, null, 2));
+}
+async function createDocument(args) {
+  const body = parseFlags(args, ["title", "type", "parentId"]);
+  const [baseUrl, apiKey] = await Promise.all([getBaseUrl(), getApiKey()]);
+  const result = await request(baseUrl, "/api/v1/documents", apiKey, {
+    method: "POST",
+    body
+  });
+  console.log(`Created: ${result.data.id}  ${result.data.title || "(Untitled)"}`);
+}
+async function updateDocument(id, args) {
+  if (!id) {
+    console.error("Usage: artisense docs update <document-id> --title '...' --content '...'");
+    process.exit(1);
+  }
+  const body = parseFlags(args, ["title", "content"]);
+  if (Object.keys(body).length === 0) {
+    console.error("Provide at least one of: --title, --content");
+    process.exit(1);
+  }
+  const [baseUrl, apiKey] = await Promise.all([getBaseUrl(), getApiKey()]);
+  const result = await request(baseUrl, `/api/v1/documents/${id}`, apiKey, { method: "PATCH", body });
+  console.log(`Updated: ${result.data.id}  ${result.data.title || "(Untitled)"}`);
+}
+async function deleteDocument(id) {
+  if (!id) {
+    console.error("Usage: artisense docs delete <document-id>");
+    process.exit(1);
+  }
+  const [baseUrl, apiKey] = await Promise.all([getBaseUrl(), getApiKey()]);
+  await request(baseUrl, `/api/v1/documents/${id}`, apiKey, {
+    method: "DELETE"
+  });
+  console.log(`Deleted: ${id}`);
+}
+function parseFlags(args, allowedKeys) {
+  const result = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (allowedKeys.includes(key) && i + 1 < args.length) {
+        result[key] = args[++i];
+      }
+    }
+  }
+  return result;
+}
+function printUsage2() {
+  console.log(`
+Usage: artisense docs <command>
+
+Commands:
+  list                          List all documents
+  get <id>                      Get a document
+  create --title "..." [--type "..."] [--parentId "..."]
+                                Create a document
+  update <id> --title "..." --content "..."
+                                Update a document
+  delete <id>                   Delete a document
+`);
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+switch (command) {
+  case "skill":
+    await skillCommand(args.slice(1));
+    break;
+  case "docs":
+  case "documents":
+    await documentsCommand(args.slice(1));
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    printHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+}
+function printHelp() {
+  console.log(`
+artisense — CLI for Artisense
+
+Usage: artisense <command>
+
+Commands:
+  skill               Download SKILL.md for AI agents
+  docs                Manage documents (list, get, create, update, delete)
+  help                Show this help
+
+Environment:
+  ARTISENSE_API_KEY   Your API key (required for docs commands)
+
+Examples:
+  artisense skill --claude
+  artisense docs list
+  artisense docs get <id>
+  artisense docs create --title "Meeting Notes"
+  artisense docs update <id> --content "Updated content"
+  artisense docs delete <id>
+`);
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "artisense",
+  "version": "0.1.0",
+  "description": "CLI for Artisense — manage documents from your terminal or AI agent",
+  "license": "MIT",
+  "bin": {
+    "artisense": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "dev": "bun run src/index.ts"
+  }
+}