@agentick/cli 0.0.1

package/src/cli.ts

@@ -0,0 +1,206 @@
+/**
+ * CLI - Main CLI class
+ */
+
+import { createClient, type AgentickClient, type AgentickClientConfig } from "@agentick/client";
+import EventSource from "eventsource";
+import { EventEmitter } from "events";
+
+/**
+ * CLI configuration
+ */
+export interface CLIConfig {
+  /** Server URL */
+  url: string;
+
+  /** Session ID (optional - server will create one if not provided) */
+  sessionId?: string;
+
+  /** Authentication token */
+  token?: string;
+
+  /** Enable streaming (default: true) */
+  streaming?: boolean;
+
+  /** Enable debug mode */
+  debug?: boolean;
+
+  /** Custom headers */
+  headers?: Record<string, string>;
+}
+
+/**
+ * CLI event types
+ */
+export interface CLIEvents {
+  connected: [];
+  disconnected: [];
+  error: [Error];
+  "message:sent": [{ content: string }];
+  "message:received": [{ content: string; tokens?: { input: number; output: number } }];
+  "stream:delta": [{ text: string }];
+  "stream:start": [];
+  "stream:end": [];
+  "tool:start": [{ name: string; args: Record<string, unknown> }];
+  "tool:end": [{ name: string; result: unknown }];
+}
+
+/**
+ * CLI class for programmatic usage
+ */
+export class CLI extends EventEmitter {
+  private client: AgentickClient;
+  private config: CLIConfig;
+  private _sessionId?: string;
+  private _isConnected = false;
+
+  constructor(config: CLIConfig) {
+    super();
+    this.config = config;
+
+    // Create client with Node.js EventSource
+    const clientConfig: AgentickClientConfig = {
+      baseUrl: config.url,
+      token: config.token,
+      headers: config.headers,
+      // @ts-expect-error - EventSource types differ slightly
+      EventSource: EventSource,
+    };
+
+    this.client = createClient(clientConfig);
+    this._sessionId = config.sessionId;
+
+    // Forward connection state changes
+    this.client.onConnectionChange((state) => {
+      if (state === "connected" && !this._isConnected) {
+        this._isConnected = true;
+        this.emit("connected");
+      } else if (state === "disconnected" && this._isConnected) {
+        this._isConnected = false;
+        this.emit("disconnected");
+      } else if (state === "error") {
+        this.emit("error", new Error("Connection error"));
+      }
+    });
+  }
+
+  get sessionId(): string | undefined {
+    return this._sessionId;
+  }
+
+  get isConnected(): boolean {
+    return this._isConnected;
+  }
+
+  /**
+   * Send a message and get the response
+   */
+  async send(message: string): Promise<string> {
+    const handle = this.client.send(message, {
+      sessionId: this._sessionId,
+    });
+
+    // Track session ID from response
+    let response = "";
+
+    this.emit("stream:start");
+
+    for await (const event of handle) {
+      // Update session ID if we get one
+      if ("sessionId" in event && event.sessionId) {
+        this._sessionId = event.sessionId;
+      }
+
+      switch (event.type) {
+        case "content_delta":
+          if ("delta" in event) {
+            const delta = (event as { delta: string }).delta;
+            response += delta;
+            this.emit("stream:delta", { text: delta });
+          }
+          break;
+
+        case "tool_call_start":
+          if ("name" in event) {
+            const toolStart = event as unknown as { name: string; input?: Record<string, unknown> };
+            this.emit("tool:start", {
+              name: toolStart.name,
+              args: toolStart.input ?? {},
+            });
+          }
+          break;
+
+        case "tool_result":
+          if ("name" in event) {
+            const toolResult = event as unknown as { name: string; result?: unknown };
+            this.emit("tool:end", {
+              name: toolResult.name,
+              result: toolResult.result,
+            });
+          }
+          break;
+      }
+    }
+
+    this.emit("stream:end");
+
+    // Get final result
+    try {
+      const result = await handle.result;
+      if (result?.response) {
+        response =
+          typeof result.response === "string" ? result.response : JSON.stringify(result.response);
+      }
+
+      this.emit("message:received", {
+        content: response,
+        tokens: result?.usage
+          ? {
+              input: result.usage.inputTokens ?? 0,
+              output: result.usage.outputTokens ?? 0,
+            }
+          : undefined,
+      });
+    } catch (error) {
+      // Result might fail if we already consumed the stream
+      if (!response) {
+        throw error;
+      }
+    }
+
+    return response;
+  }
+
+  /**
+   * Send a message and stream the response
+   */
+  async *stream(message: string): AsyncGenerator<{ type: string; data: unknown }> {
+    const handle = this.client.send(message, {
+      sessionId: this._sessionId,
+    });
+
+    for await (const event of handle) {
+      // Update session ID
+      if ("sessionId" in event && event.sessionId) {
+        this._sessionId = event.sessionId;
+      }
+
+      yield { type: event.type, data: event };
+    }
+  }
+
+  /**
+   * Destroy the client
+   */
+  destroy(): void {
+    this.client.destroy();
+    this._isConnected = false;
+  }
+}
+
+/**
+ * Create a CLI instance
+ */
+export function createCLI(config: CLIConfig): CLI {
+  return new CLI(config);
+}

package/src/commands/chat.ts

@@ -0,0 +1,34 @@
+/**
+ * Chat command - Interactive chat mode
+ */
+
+import { ChatSession } from "../chat-session.js";
+import { loadConfig } from "../config.js";
+
+interface ChatOptions {
+  url?: string;
+  session?: string;
+  token?: string;
+  stream?: boolean;
+  debug?: boolean;
+}
+
+export async function chatCommand(options: ChatOptions): Promise<void> {
+  // Load config with CLI overrides
+  const config = loadConfig(options);
+
+  if (!config.url) {
+    console.error("Error: Server URL is required. Use --url or set TENTICKLE_URL.");
+    process.exit(1);
+  }
+
+  const session = new ChatSession({
+    url: config.url,
+    sessionId: config.sessionId,
+    token: config.token,
+    streaming: options.stream !== false,
+    debug: options.debug,
+  });
+
+  await session.start();
+}

package/src/commands/send.ts

@@ -0,0 +1,95 @@
+/**
+ * Send command - Non-interactive message sending
+ */
+
+import * as fs from "fs";
+import { CLI } from "../cli.js";
+import { Renderer } from "../ui/renderer.js";
+import { loadConfig } from "../config.js";
+
+interface SendOptions {
+  url?: string;
+  session?: string;
+  token?: string;
+  stdin?: boolean;
+  format?: "plain" | "json" | "markdown";
+  stream?: boolean;
+}
+
+export async function sendCommand(message: string, options: SendOptions): Promise<void> {
+  const config = loadConfig(options);
+
+  if (!config.url) {
+    console.error("Error: Server URL is required. Use --url or set TENTICKLE_URL.");
+    process.exit(1);
+  }
+
+  const renderer = new Renderer({
+    markdown: options.format === "markdown",
+  });
+
+  // Read stdin if requested
+  let fullMessage = message;
+  if (options.stdin) {
+    const stdinData = fs.readFileSync(0, "utf-8");
+    fullMessage = `${message}\n\n${stdinData}`;
+  }
+
+  const cli = new CLI({
+    url: config.url,
+    sessionId: config.sessionId,
+    token: config.token,
+    streaming: options.stream !== false,
+  });
+
+  try {
+    let response = "";
+
+    if (options.stream !== false) {
+      // Stream mode - show output as it arrives
+      cli.on("stream:delta", ({ text }) => {
+        process.stdout.write(text);
+      });
+
+      cli.on("tool:start", ({ name }) => {
+        if (options.format !== "json") {
+          process.stderr.write(`\n[tool: ${name}]\n`);
+        }
+      });
+
+      response = await cli.send(fullMessage);
+      console.log(); // Newline after streaming
+    } else {
+      // Non-stream mode - wait for complete response
+      response = await cli.send(fullMessage);
+    }
+
+    // Output based on format
+    switch (options.format) {
+      case "json":
+        renderer.json({
+          response,
+          sessionId: cli.sessionId,
+        });
+        break;
+      case "markdown":
+        if (options.stream === false) {
+          renderer.response(response);
+        }
+        break;
+      case "plain":
+      default:
+        if (options.stream === false) {
+          renderer.plain(response);
+        }
+        break;
+    }
+
+    cli.destroy();
+    process.exit(0);
+  } catch (error) {
+    renderer.error(error instanceof Error ? error.message : String(error));
+    cli.destroy();
+    process.exit(1);
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,32 @@
+/**
+ * Status command - Show server and session status
+ */
+
+import { Renderer } from "../ui/renderer.js";
+import { loadConfig } from "../config.js";
+
+interface StatusOptions {
+  url?: string;
+  session?: string;
+  token?: string;
+}
+
+export async function statusCommand(options: StatusOptions): Promise<void> {
+  const config = loadConfig(options);
+  const renderer = new Renderer();
+
+  if (!config.url) {
+    console.error("Error: Server URL is required. Use --url or set TENTICKLE_URL.");
+    process.exit(1);
+  }
+
+  renderer.info("\nAgentick Status");
+  renderer.separator();
+  renderer.info(`URL: ${config.url}`);
+  renderer.info(`Session: ${config.sessionId ?? "(auto-create)"}`);
+  renderer.info(`Token: ${config.token ? "(set)" : "(not set)"}`);
+  renderer.separator();
+
+  renderer.info("\nNote: Server status check not yet implemented.");
+  renderer.info("Use 'agentick chat' to connect and '/status' for session info.\n");
+}

package/src/config.ts

@@ -0,0 +1,123 @@
+/**
+ * Configuration loading and management
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+/**
+ * CLI configuration
+ */
+export interface Config {
+  url?: string;
+  sessionId?: string;
+  token?: string;
+  debug?: boolean;
+}
+
+/**
+ * Config file structure
+ */
+interface ConfigFile {
+  defaultUrl?: string;
+  defaultToken?: string;
+  aliases?: Record<string, string>;
+  debug?: boolean;
+}
+
+/**
+ * Get config file path
+ */
+function getConfigPath(): string {
+  return path.join(os.homedir(), ".agentick", "config.json");
+}
+
+/**
+ * Load config file
+ */
+function loadConfigFile(): ConfigFile | null {
+  const configPath = getConfigPath();
+
+  try {
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf-8");
+      return JSON.parse(content) as ConfigFile;
+    }
+  } catch {
+    // Ignore config file errors
+  }
+
+  return null;
+}
+
+/**
+ * Resolve URL alias
+ */
+function resolveAlias(url: string, configFile: ConfigFile | null): string {
+  if (configFile?.aliases && configFile.aliases[url]) {
+    return configFile.aliases[url];
+  }
+  return url;
+}
+
+/**
+ * Load configuration from environment, config file, and CLI options
+ */
+export function loadConfig(cliOptions: {
+  url?: string;
+  session?: string;
+  token?: string;
+  debug?: boolean;
+}): Config {
+  const configFile = loadConfigFile();
+
+  // Priority: CLI > Environment > Config file
+  let url = cliOptions.url ?? process.env.TENTICKLE_URL ?? configFile?.defaultUrl;
+
+  // Resolve alias if URL looks like one
+  if (url && !url.includes("://")) {
+    url = resolveAlias(url, configFile);
+  }
+
+  const sessionId = cliOptions.session ?? process.env.TENTICKLE_SESSION;
+
+  const token = cliOptions.token ?? process.env.TENTICKLE_TOKEN ?? configFile?.defaultToken;
+
+  const debug =
+    cliOptions.debug || process.env.TENTICKLE_DEBUG === "1" || configFile?.debug || false;
+
+  return {
+    url,
+    sessionId,
+    token,
+    debug,
+  };
+}
+
+/**
+ * Save configuration
+ */
+export function saveConfig(config: Partial<ConfigFile>): void {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure directory exists
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  // Load existing config
+  let existing: ConfigFile = {};
+  try {
+    if (fs.existsSync(configPath)) {
+      existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+  } catch {
+    // Ignore
+  }
+
+  // Merge and save
+  const merged = { ...existing, ...config };
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2));
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @agentick/cli - Terminal client for Agentick agents
+ *
+ * Provides interactive and non-interactive modes for communicating
+ * with Agentick servers.
+ *
+ * @module @agentick/cli
+ */
+
+export { CLI, createCLI, type CLIConfig, type CLIEvents } from "./cli.js";
+export { ChatSession, type ChatSessionOptions } from "./chat-session.js";
+export { Renderer, type RendererOptions } from "./ui/renderer.js";

package/src/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Type declarations for modules without types
+ */
+
+declare module "marked-terminal" {
+  import type { MarkedExtension } from "marked";
+
+  interface MarkedTerminalOptions {
+    code?: (code: string) => string;
+    blockquote?: (quote: string) => string;
+    html?: (html: string) => string;
+    heading?: (text: string) => string;
+    firstHeading?: (text: string) => string;
+    hr?: () => string;
+    listitem?: (text: string) => string;
+    table?: (header: string, body: string) => string;
+    paragraph?: (text: string) => string;
+    strong?: (text: string) => string;
+    em?: (text: string) => string;
+    codespan?: (code: string) => string;
+    del?: (text: string) => string;
+    link?: (href: string, title: string | null, text: string) => string;
+    href?: (href: string) => string;
+    reflowText?: boolean;
+    width?: number;
+    showSectionPrefix?: boolean;
+    unescape?: boolean;
+    emoji?: boolean;
+    tab?: number;
+  }
+
+  export function markedTerminal(options?: MarkedTerminalOptions): MarkedExtension;
+}