@ch4p/cli 0.1.0

package/dist/audit-BIGXGJSQ.js

@@ -0,0 +1,12 @@
+import {
+  audit,
+  performAudit,
+  runAudit
+} from "./chunk-TEVLTQYT.js";
+import "./chunk-NRFRTZVP.js";
+import "./chunk-NMGPBPNU.js";
+export {
+  audit,
+  performAudit,
+  runAudit
+};

package/dist/canvas-OIXBPYUL.js

@@ -0,0 +1,313 @@
+import {
+  CanvasSessionManager,
+  CanvasTool,
+  GatewayServer,
+  PairingManager,
+  SessionManager
+} from "./chunk-GEFQONOB.js";
+import {
+  DefaultSecurityPolicy,
+  NativeEngine,
+  ProviderRegistry,
+  createClaudeCliEngine,
+  createCodexCliEngine,
+  createMemoryBackend,
+  createObserver
+} from "./chunk-7EUURDQ5.js";
+import {
+  LoadSkillTool,
+  ToolRegistry
+} from "./chunk-PGZ24EFT.js";
+import {
+  SkillRegistry
+} from "./chunk-6BURGD2Y.js";
+import {
+  AgentLoop
+} from "./chunk-IRNN57EQ.js";
+import {
+  generateId
+} from "./chunk-YSCX2QQQ.js";
+import {
+  getLogsDir,
+  loadConfig
+} from "./chunk-NRFRTZVP.js";
+import {
+  BOLD,
+  DIM,
+  GREEN,
+  RED,
+  RESET,
+  TEAL,
+  separator
+} from "./chunk-NMGPBPNU.js";
+
+// src/commands/canvas.ts
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+async function canvas(args) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`
+  ${RED}Failed to load config:${RESET} ${message}`);
+    console.error(`  ${DIM}Run ${TEAL}ch4p onboard${DIM} to set up ch4p.${RESET}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  let port = config.canvas?.port ?? config.gateway.port ?? 4800;
+  let autoOpen = true;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && args[i + 1]) {
+      const parsed = parseInt(args[i + 1], 10);
+      if (!isNaN(parsed) && parsed > 0 && parsed <= 65535) {
+        port = parsed;
+      }
+    }
+    if (args[i] === "--no-open") {
+      autoOpen = false;
+    }
+  }
+  const host = "127.0.0.1";
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const staticDir = resolve(__dirname, "..", "..", "..", "apps", "web", "dist");
+  const sessionManager = new SessionManager();
+  const pairingManager = config.canvas?.requirePairing ? new PairingManager() : void 0;
+  const canvasSessionManager = new CanvasSessionManager();
+  const engine = createCanvasEngine(config);
+  if (!engine) {
+    console.error(`
+  ${RED}No LLM engine available.${RESET}`);
+    console.error(`  ${DIM}Ensure an API key is configured. Run ${TEAL}ch4p onboard${DIM}.${RESET}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const obsCfg = {
+    observers: config.observability.observers ?? ["console"],
+    logLevel: config.observability.logLevel ?? "info",
+    logPath: `${getLogsDir()}/canvas.jsonl`
+  };
+  const observer = createObserver(obsCfg);
+  let memoryBackend;
+  try {
+    const memCfg = {
+      backend: config.memory.backend,
+      vectorWeight: config.memory.vectorWeight,
+      keywordWeight: config.memory.keywordWeight,
+      embeddingProvider: config.memory.embeddingProvider,
+      openaiApiKey: config.providers?.openai?.apiKey || void 0
+    };
+    memoryBackend = createMemoryBackend(memCfg);
+  } catch {
+  }
+  let skillRegistry;
+  try {
+    if (config.skills?.enabled && config.skills?.paths?.length) {
+      skillRegistry = SkillRegistry.createFromPaths(config.skills.paths);
+    }
+  } catch {
+  }
+  const sessionId = generateId(16);
+  const defaultSessionConfig = {
+    engineId: config.engines?.default ?? "native",
+    model: config.agent.model,
+    provider: config.agent.provider,
+    systemPrompt: "You are ch4p, an AI assistant with an interactive canvas workspace. You can render visual components on the canvas using the canvas_render tool. Available component types: card, chart, form, button, text_field, data_table, code_block, markdown, image, progress, status. Components are placed at (x, y) positions on a spatial canvas. You can connect components with directional edges to show relationships. Use the canvas to create rich, visual responses when appropriate."
+  };
+  const server = new GatewayServer({
+    port,
+    host,
+    sessionManager,
+    pairingManager,
+    canvasSessionManager,
+    staticDir,
+    defaultSessionConfig,
+    onCanvasConnection: (connSessionId, bridge) => {
+      wireCanvasSession(
+        connSessionId,
+        bridge,
+        canvasSessionManager,
+        engine,
+        config,
+        observer,
+        memoryBackend,
+        skillRegistry,
+        defaultSessionConfig
+      );
+    }
+  });
+  console.log(`
+  ${TEAL}${BOLD}ch4p Canvas${RESET}`);
+  console.log(separator());
+  console.log("");
+  try {
+    await server.start();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`  ${RED}Failed to start server:${RESET} ${message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const addr = server.getAddress();
+  const bindDisplay = addr ? `${addr.host}:${addr.port}` : `${host}:${port}`;
+  const url = `http://${bindDisplay}/?session=${sessionId}`;
+  console.log(`  ${GREEN}${BOLD}Server listening${RESET} on ${bindDisplay}`);
+  console.log(`  ${BOLD}Session${RESET}       ${sessionId}`);
+  console.log(`  ${BOLD}Engine${RESET}        ${engine.name}`);
+  console.log(`  ${BOLD}Static dir${RESET}    ${DIM}${staticDir}${RESET}`);
+  console.log("");
+  console.log(`  ${BOLD}Routes:${RESET}`);
+  console.log(`  ${DIM}  WS     /ws/:sessionId       - WebSocket canvas connection${RESET}`);
+  console.log(`  ${DIM}  GET    /health               - liveness probe${RESET}`);
+  console.log(`  ${DIM}  GET    /*                    - static files (web UI)${RESET}`);
+  console.log("");
+  if (pairingManager) {
+    const code = pairingManager.generateCode("Canvas startup");
+    console.log(`  ${BOLD}Pairing code:${RESET} ${TEAL}${BOLD}${code.code}${RESET}`);
+    console.log(`  ${DIM}Add ?token=YOUR_TOKEN to the URL after pairing.${RESET}`);
+    console.log("");
+  }
+  console.log(`  ${GREEN}${BOLD}Canvas URL:${RESET} ${TEAL}${url}${RESET}`);
+  console.log("");
+  if (autoOpen) {
+    try {
+      const platform = process.platform;
+      const openCmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+      execSync(`${openCmd} "${url}"`, { stdio: "ignore" });
+      console.log(`  ${DIM}Browser opened.${RESET}`);
+    } catch {
+      console.log(`  ${DIM}Couldn't auto-open browser. Open the URL above manually.${RESET}`);
+    }
+  }
+  console.log(`  ${DIM}Press Ctrl+C to stop.${RESET}
+`);
+  await new Promise((resolvePromise) => {
+    const shutdown = async () => {
+      console.log(`
+  ${DIM}Shutting down canvas...${RESET}`);
+      canvasSessionManager.endAll();
+      if (memoryBackend) {
+        try {
+          await memoryBackend.close();
+        } catch {
+        }
+      }
+      await server.stop();
+      await observer.flush?.();
+      console.log(`  ${DIM}Goodbye!${RESET}
+`);
+      resolvePromise();
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+  });
+}
+function createCanvasEngine(config) {
+  const engineId = config.engines?.default ?? "native";
+  const engineConfig = config.engines?.available?.[engineId];
+  if (engineId === "claude-cli") {
+    try {
+      return createClaudeCliEngine({
+        command: engineConfig?.command ?? void 0,
+        cwd: engineConfig?.cwd ?? void 0,
+        timeout: engineConfig?.timeout ?? void 0
+      });
+    } catch {
+    }
+  }
+  if (engineId === "codex-cli") {
+    try {
+      return createCodexCliEngine({
+        command: engineConfig?.command ?? void 0,
+        cwd: engineConfig?.cwd ?? void 0,
+        timeout: engineConfig?.timeout ?? void 0
+      });
+    } catch {
+    }
+  }
+  const providerName = config.agent.provider;
+  const providerConfig = config.providers?.[providerName];
+  const apiKey = providerConfig?.apiKey;
+  if (providerName !== "ollama" && (!apiKey || apiKey.trim().length === 0)) {
+    return null;
+  }
+  try {
+    const provider = ProviderRegistry.createProvider({
+      id: providerName,
+      type: providerName,
+      ...providerConfig
+    });
+    return new NativeEngine({ provider, defaultModel: config.agent.model });
+  } catch {
+    return null;
+  }
+}
+function wireCanvasSession(sessionId, bridge, canvasSessionManager, engine, config, observer, memoryBackend, skillRegistry, defaultSessionConfig) {
+  const entry = canvasSessionManager.getSession(sessionId);
+  if (!entry) return;
+  const { canvasState, canvasChannel } = entry;
+  canvasChannel.start({ sessionId }).catch(() => {
+  });
+  canvasChannel.onMessage((msg) => {
+    void (async () => {
+      try {
+        if (msg.text.startsWith("[ABORT]")) {
+          return;
+        }
+        const session = new (await import("./dist-VZE4JK7Q.js")).Session({
+          sessionId,
+          ...defaultSessionConfig
+        });
+        const exclude = config.autonomy.level === "readonly" ? ["bash", "file_write", "file_edit", "delegate"] : ["delegate"];
+        if (!config.mesh?.enabled) {
+          exclude.push("mesh");
+        }
+        const tools = ToolRegistry.createDefault({ exclude });
+        tools.register(new CanvasTool());
+        if (skillRegistry && skillRegistry.size > 0) {
+          tools.register(new LoadSkillTool(skillRegistry));
+        }
+        const securityPolicy = new DefaultSecurityPolicy({
+          workspace: process.cwd(),
+          autonomyLevel: config.autonomy.level,
+          allowedCommands: config.autonomy.allowedCommands,
+          blockedPaths: config.security.blockedPaths
+        });
+        const toolContextExtensions = {
+          canvasState
+        };
+        if (config.search?.enabled && config.search.apiKey) {
+          toolContextExtensions.searchApiKey = config.search.apiKey;
+          toolContextExtensions.searchConfig = {
+            maxResults: config.search.maxResults,
+            country: config.search.country,
+            searchLang: config.search.searchLang
+          };
+        }
+        const loop = new AgentLoop(session, engine, tools.list(), observer, {
+          maxIterations: 30,
+          maxRetries: 2,
+          enableStateSnapshots: true,
+          memoryBackend,
+          securityPolicy,
+          toolContextExtensions
+        });
+        for await (const event of loop.run(msg.text)) {
+          bridge.handleAgentEvent(event);
+        }
+      } catch (err) {
+        bridge.handleAgentEvent({
+          type: "error",
+          error: err instanceof Error ? err : new Error(String(err))
+        });
+      }
+    })();
+  });
+}
+export {
+  canvas
+};

package/dist/chunk-6BURGD2Y.js

@@ -0,0 +1,290 @@
+// ../../packages/skills/dist/index.js
+import { readdirSync, readFileSync, existsSync, statSync } from "fs";
+import { resolve, basename, join } from "path";
+import { homedir } from "os";
+var SkillParseError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "SkillParseError";
+  }
+};
+var NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+function parseSkillManifest(content, filePath) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    throw new SkillParseError(
+      "SKILL.md must start with YAML frontmatter (---)",
+      filePath
+    );
+  }
+  const afterOpening = trimmed.slice(3);
+  const closingIndex = afterOpening.indexOf("\n---");
+  if (closingIndex === -1) {
+    throw new SkillParseError(
+      "SKILL.md frontmatter is missing closing ---",
+      filePath
+    );
+  }
+  const yamlBlock = afterOpening.slice(0, closingIndex).trim();
+  const body = afterOpening.slice(closingIndex + 4).trim();
+  const manifest = parseYamlBlock(yamlBlock, filePath);
+  validateManifest(manifest, filePath);
+  return { manifest, body };
+}
+function parseYamlBlock(yaml, _filePath) {
+  const lines = yaml.split("\n");
+  const result = {};
+  let currentKey = null;
+  let multilineValue = "";
+  let inMultiline = false;
+  let inNestedObject = false;
+  let nestedKey = null;
+  let nestedObj = {};
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (inMultiline) {
+      if (line.match(/^\s{2,}/) || line.trim() === "") {
+        multilineValue += (multilineValue ? "\n" : "") + line.replace(/^\s{2,}/, "");
+        continue;
+      } else {
+        result[currentKey] = multilineValue.trim();
+        inMultiline = false;
+        currentKey = null;
+        multilineValue = "";
+      }
+    }
+    if (inNestedObject) {
+      const nestedMatch = line.match(/^\s{2,}(\w[\w-]*):\s*(.+)/);
+      if (nestedMatch) {
+        nestedObj[nestedMatch[1]] = stripQuotes(nestedMatch[2].trim());
+        continue;
+      } else {
+        result[nestedKey] = Object.keys(nestedObj).length > 0 ? { ...nestedObj } : "";
+        inNestedObject = false;
+        nestedKey = null;
+        nestedObj = {};
+      }
+    }
+    if (line.trim() === "") continue;
+    const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+    if (!kvMatch) continue;
+    const key = kvMatch[1];
+    const rawValue = kvMatch[2].trim();
+    if (rawValue === "|") {
+      currentKey = key;
+      inMultiline = true;
+      multilineValue = "";
+    } else if (rawValue === "") {
+      nestedKey = key;
+      inNestedObject = true;
+      nestedObj = {};
+    } else if (rawValue.startsWith("[")) {
+      result[key] = parseInlineArray(rawValue);
+    } else {
+      result[key] = stripQuotes(rawValue);
+    }
+  }
+  if (inMultiline && currentKey) {
+    result[currentKey] = multilineValue.trim();
+  }
+  if (inNestedObject && nestedKey) {
+    result[nestedKey] = Object.keys(nestedObj).length > 0 ? { ...nestedObj } : "";
+  }
+  return {
+    name: String(result.name ?? ""),
+    description: String(result.description ?? ""),
+    license: result.license ? String(result.license) : void 0,
+    compatibility: Array.isArray(result.compatibility) ? result.compatibility.map(String) : void 0,
+    metadata: result.metadata && typeof result.metadata === "object" ? result.metadata : void 0
+  };
+}
+function parseInlineArray(raw) {
+  const inner = raw.replace(/^\[/, "").replace(/\]$/, "").trim();
+  if (!inner) return [];
+  return inner.split(",").map((item) => stripQuotes(item.trim()));
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function validateManifest(manifest, filePath) {
+  if (!manifest.name) {
+    throw new SkillParseError("Skill manifest is missing required field: name", filePath);
+  }
+  if (!NAME_REGEX.test(manifest.name)) {
+    throw new SkillParseError(
+      `Invalid skill name "${manifest.name}": must be lowercase alphanumeric with hyphens (a-z, 0-9, -)`,
+      filePath
+    );
+  }
+  if (manifest.name.length > MAX_NAME_LENGTH) {
+    throw new SkillParseError(
+      `Skill name "${manifest.name}" exceeds maximum length of ${MAX_NAME_LENGTH} characters`,
+      filePath
+    );
+  }
+  if (!manifest.description) {
+    throw new SkillParseError(
+      "Skill manifest is missing required field: description",
+      filePath
+    );
+  }
+  if (manifest.description.length > MAX_DESCRIPTION_LENGTH) {
+    throw new SkillParseError(
+      `Skill description exceeds maximum length of ${MAX_DESCRIPTION_LENGTH} characters`,
+      filePath
+    );
+  }
+}
+function classifySource(dirPath) {
+  const home = homedir();
+  if (dirPath.startsWith(resolve(home, ".ch4p"))) return "global";
+  if (dirPath.includes(".agents/skills")) return "legacy";
+  return "project";
+}
+function expandTilde(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function loadSkill(skillDir) {
+  const skillPath = join(skillDir, "SKILL.md");
+  if (!existsSync(skillPath)) return null;
+  const content = readFileSync(skillPath, "utf8");
+  const { manifest, body } = parseSkillManifest(content, skillPath);
+  const dirName = basename(skillDir);
+  if (dirName.toLowerCase() !== manifest.name.toLowerCase()) {
+    throw new SkillParseError(
+      `Directory name "${dirName}" does not match manifest name "${manifest.name}"`,
+      skillPath
+    );
+  }
+  const source = classifySource(skillDir);
+  return { manifest, body, path: skillPath, source };
+}
+function discoverSkills(searchPaths) {
+  const skillMap = /* @__PURE__ */ new Map();
+  for (const rawPath of searchPaths) {
+    const searchDir = expandTilde(rawPath);
+    if (!existsSync(searchDir)) continue;
+    let entries;
+    try {
+      entries = readdirSync(searchDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = resolve(searchDir, entry);
+      try {
+        if (!statSync(fullPath).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      try {
+        const skill = loadSkill(fullPath);
+        if (skill) {
+          skillMap.set(skill.manifest.name, skill);
+        }
+      } catch (err) {
+        if (err instanceof SkillParseError) {
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  return Array.from(skillMap.values());
+}
+var SkillRegistry = class _SkillRegistry {
+  skills = /* @__PURE__ */ new Map();
+  /**
+   * Register a skill. Throws if a skill with the same name is already registered.
+   */
+  register(skill) {
+    if (this.skills.has(skill.manifest.name)) {
+      throw new SkillParseError(
+        `Skill "${skill.manifest.name}" is already registered.`,
+        skill.path
+      );
+    }
+    this.skills.set(skill.manifest.name, skill);
+  }
+  /**
+   * Get a skill by name. Returns undefined if not found.
+   */
+  get(name) {
+    return this.skills.get(name);
+  }
+  /**
+   * Check whether a skill is registered.
+   */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /**
+   * List all registered skills.
+   */
+  list() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * List skill names.
+   */
+  names() {
+    return Array.from(this.skills.keys());
+  }
+  /**
+   * Unregister a skill by name. Returns true if removed, false if not found.
+   */
+  unregister(name) {
+    return this.skills.delete(name);
+  }
+  /**
+   * Get skill descriptions for system prompt injection.
+   * Returns name + description pairs for progressive disclosure.
+   */
+  getDescriptions() {
+    return this.list().map((skill) => ({
+      name: skill.manifest.name,
+      description: skill.manifest.description
+    }));
+  }
+  /**
+   * Get the full markdown body for a skill (on-demand loading).
+   * Returns the instruction content that gets injected into context
+   * when the agent determines a skill is relevant.
+   */
+  getSkillContext(name) {
+    return this.skills.get(name)?.body;
+  }
+  /**
+   * Get the count of registered skills.
+   */
+  get size() {
+    return this.skills.size;
+  }
+  /**
+   * Create a registry by discovering skills from search paths.
+   *
+   * Scans directories for SKILL.md files, parses manifests, and registers
+   * all valid skills. Invalid manifests are silently skipped.
+   */
+  static createFromPaths(searchPaths) {
+    const registry = new _SkillRegistry();
+    const skills = discoverSkills(searchPaths);
+    for (const skill of skills) {
+      registry.register(skill);
+    }
+    return registry;
+  }
+};
+
+export {
+  SkillRegistry
+};