autohand-cli 0.2.0

package/dist/chunk-OC5YDNFC.js

@@ -0,0 +1,373 @@
+// src/commands/export.ts
+import chalk from "chalk";
+import path2 from "path";
+import enquirer from "enquirer";
+
+// src/session/exportSession.ts
+import fs from "fs-extra";
+import path from "path";
+var DEFAULT_OPTIONS = {
+  includeToolOutputs: true,
+  includeTimestamps: false,
+  includeMetadata: true,
+  maxCodeBlockLength: 500,
+  includeToc: false
+};
+function formatCodeBlock(code, language, maxLength) {
+  let content = code;
+  if (maxLength && content.length > maxLength) {
+    content = content.slice(0, maxLength) + "\n... (truncated)";
+  }
+  const lang = language || "";
+  return "```" + lang + "\n" + content + "\n```";
+}
+function detectLanguage(content, context) {
+  if (context) {
+    const extMatch = context.match(/\.(\w+)$/);
+    if (extMatch) {
+      const ext = extMatch[1].toLowerCase();
+      const langMap = {
+        ts: "typescript",
+        tsx: "typescript",
+        js: "javascript",
+        jsx: "javascript",
+        py: "python",
+        rs: "rust",
+        go: "go",
+        rb: "ruby",
+        java: "java",
+        cpp: "cpp",
+        c: "c",
+        sh: "bash",
+        bash: "bash",
+        json: "json",
+        yaml: "yaml",
+        yml: "yaml",
+        md: "markdown",
+        sql: "sql",
+        html: "html",
+        css: "css"
+      };
+      return langMap[ext] || ext;
+    }
+  }
+  if (content.includes("function") || content.includes("const ") || content.includes("let ")) {
+    return "javascript";
+  }
+  if (content.includes("def ") || content.includes("import ") && content.includes(":")) {
+    return "python";
+  }
+  if (content.includes("fn ") || content.includes("let mut")) {
+    return "rust";
+  }
+  if (content.includes("func ") || content.includes("package ")) {
+    return "go";
+  }
+  return "";
+}
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function formatMessage(message, options, index) {
+  const parts = [];
+  const roleEmoji = {
+    user: "\u{1F464}",
+    assistant: "\u{1F916}",
+    tool: "\u{1F527}",
+    system: "\u2699\uFE0F"
+  };
+  const emoji = roleEmoji[message.role] || "\u{1F4AC}";
+  const roleLabel = message.role.charAt(0).toUpperCase() + message.role.slice(1);
+  const timestamp = options.includeTimestamps && message.timestamp ? ` (${formatTimestamp(message.timestamp)})` : "";
+  parts.push(`### ${emoji} ${roleLabel}${timestamp}`);
+  parts.push("");
+  if (message.role === "tool") {
+    if (options.includeToolOutputs) {
+      const toolName = message.name || "Tool";
+      parts.push(`**${toolName}**`);
+      parts.push("");
+      if (message.content.includes("\n") || message.content.length > 100) {
+        const lang = detectLanguage(message.content, message.name);
+        parts.push(formatCodeBlock(message.content, lang, options.maxCodeBlockLength));
+      } else {
+        parts.push(`> ${message.content}`);
+      }
+    } else {
+      parts.push("*Tool output omitted*");
+    }
+  } else {
+    const content = message.content;
+    const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRegex.exec(content)) !== null) {
+      if (match.index > lastIndex) {
+        parts.push(content.slice(lastIndex, match.index).trim());
+      }
+      const lang = match[1] || "";
+      const code = match[2];
+      parts.push(formatCodeBlock(code, lang, options.maxCodeBlockLength));
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < content.length) {
+      const remaining = content.slice(lastIndex).trim();
+      if (remaining) {
+        parts.push(remaining);
+      }
+    }
+  }
+  parts.push("");
+  parts.push("---");
+  parts.push("");
+  return parts.join("\n");
+}
+function exportToMarkdown(metadata2, messages, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const parts = [];
+  parts.push(`# ${metadata2.projectName} - Session ${metadata2.sessionId.slice(0, 8)}`);
+  parts.push("");
+  if (opts.includeMetadata) {
+    parts.push("## Session Info");
+    parts.push("");
+    parts.push(`| Property | Value |`);
+    parts.push(`|----------|-------|`);
+    parts.push(`| **Project** | ${metadata2.projectName} |`);
+    parts.push(`| **Started** | ${formatTimestamp(metadata2.createdAt)} |`);
+    if (metadata2.closedAt) {
+      parts.push(`| **Ended** | ${formatTimestamp(metadata2.closedAt)} |`);
+    }
+    parts.push(`| **Model** | ${metadata2.model} |`);
+    parts.push(`| **Messages** | ${metadata2.messageCount} |`);
+    parts.push(`| **Status** | ${metadata2.status} |`);
+    parts.push("");
+    if (metadata2.summary) {
+      parts.push("### Summary");
+      parts.push("");
+      parts.push(metadata2.summary);
+      parts.push("");
+    }
+    parts.push("---");
+    parts.push("");
+  }
+  if (opts.includeToc) {
+    parts.push("## Table of Contents");
+    parts.push("");
+    let userCount2 = 0;
+    for (const message of messages) {
+      if (message.role === "user") {
+        userCount2++;
+        const preview = message.content.slice(0, 50).replace(/\n/g, " ");
+        parts.push(`${userCount2}. [${preview}...](#message-${userCount2})`);
+      }
+    }
+    parts.push("");
+    parts.push("---");
+    parts.push("");
+  }
+  parts.push("## Conversation");
+  parts.push("");
+  let userCount = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (opts.includeToc && message.role === "user") {
+      userCount++;
+      parts.push(`<a name="message-${userCount}"></a>`);
+      parts.push("");
+    }
+    parts.push(formatMessage(message, opts, i));
+  }
+  parts.push("---");
+  parts.push("");
+  parts.push(`*Exported from Autohand CLI on ${(/* @__PURE__ */ new Date()).toLocaleString()}*`);
+  return parts.join("\n");
+}
+function exportToJson(metadata2, messages, pretty = true) {
+  const data = {
+    metadata: metadata2,
+    messages,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "1.0"
+  };
+  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+}
+function exportToHtml(metadata2, messages, options = {}) {
+  const markdown = exportToMarkdown(metadata2, messages, options);
+  const html = markdown.replace(/^### (.*$)/gm, "<h3>$1</h3>").replace(/^## (.*$)/gm, "<h2>$1</h2>").replace(/^# (.*$)/gm, "<h1>$1</h1>").replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>").replace(/\*(.*?)\*/g, "<em>$1</em>").replace(/```(\w*)\n([\s\S]*?)```/g, '<pre><code class="language-$1">$2</code></pre>').replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>').replace(/\|([^|]+)\|/g, "<td>$1</td>").replace(/^> (.*$)/gm, "<blockquote>$1</blockquote>").replace(/^---$/gm, "<hr>").replace(/\n\n/g, "</p><p>").replace(/\n/g, "<br>");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${metadata2.projectName} - Session ${metadata2.sessionId.slice(0, 8)}</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
+    h1, h2, h3 { color: #333; }
+    pre { background: #f5f5f5; padding: 1rem; border-radius: 4px; overflow-x: auto; }
+    code { background: #f5f5f5; padding: 0.2rem 0.4rem; border-radius: 3px; font-size: 0.9em; }
+    pre code { background: none; padding: 0; }
+    blockquote { border-left: 4px solid #ddd; margin: 0; padding-left: 1rem; color: #666; }
+    hr { border: none; border-top: 1px solid #ddd; margin: 1.5rem 0; }
+    table { border-collapse: collapse; width: 100%; }
+    td, th { border: 1px solid #ddd; padding: 0.5rem; text-align: left; }
+  </style>
+</head>
+<body>
+  <p>${html}</p>
+</body>
+</html>`;
+}
+async function saveExport(content, filePath) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf8");
+}
+function getSuggestedFilename(metadata2, format) {
+  const date = new Date(metadata2.createdAt);
+  const dateStr = date.toISOString().split("T")[0];
+  const projectSlug = metadata2.projectName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const sessionShort = metadata2.sessionId.slice(0, 8);
+  return `${projectSlug}-${dateStr}-${sessionShort}.${format}`;
+}
+
+// src/commands/export.ts
+var metadata = {
+  command: "/export",
+  description: "Export current session to markdown",
+  implemented: true
+};
+async function execute(args, context) {
+  if (!context?.sessionManager) {
+    console.log(chalk.red("Session manager not available."));
+    return;
+  }
+  const { sessionManager, currentSession, workspaceRoot } = context;
+  let session = currentSession;
+  if (!session) {
+    const sessions = await sessionManager.listSessions();
+    if (sessions.length === 0) {
+      console.log(chalk.yellow("No sessions found to export."));
+      return;
+    }
+    const { Select: Select2 } = enquirer;
+    const sessionPrompt = new Select2({
+      name: "session",
+      message: "Select a session to export:",
+      choices: sessions.slice(0, 10).map((s) => ({
+        name: s.sessionId,
+        message: `${s.projectName} - ${new Date(s.createdAt).toLocaleString()} (${s.messageCount} messages)`
+      }))
+    });
+    try {
+      const selectedId = await sessionPrompt.run();
+      session = await sessionManager.loadSession(selectedId);
+    } catch {
+      console.log(chalk.gray("Cancelled."));
+      return;
+    }
+  }
+  const metadata2 = session.metadata;
+  const messages = session.getMessages();
+  if (messages.length === 0) {
+    console.log(chalk.yellow("No messages in session to export."));
+    return;
+  }
+  const { Select, Confirm, Input } = enquirer;
+  const formatPrompt = new Select({
+    name: "format",
+    message: "Export format:",
+    choices: [
+      { name: "md", message: "Markdown (.md)" },
+      { name: "json", message: "JSON (.json)" },
+      { name: "html", message: "HTML (.html)" }
+    ]
+  });
+  let format;
+  try {
+    format = await formatPrompt.run();
+  } catch {
+    console.log(chalk.gray("Cancelled."));
+    return;
+  }
+  const options = {};
+  if (format === "md" || format === "html") {
+    const includeToolsPrompt = new Confirm({
+      name: "includeTools",
+      message: "Include tool outputs?",
+      initial: true
+    });
+    try {
+      options.includeToolOutputs = await includeToolsPrompt.run();
+    } catch {
+      options.includeToolOutputs = true;
+    }
+    const includeTocPrompt = new Confirm({
+      name: "includeToc",
+      message: "Include table of contents?",
+      initial: false
+    });
+    try {
+      options.includeToc = await includeTocPrompt.run();
+    } catch {
+      options.includeToc = false;
+    }
+  }
+  const suggestedFilename = getSuggestedFilename(metadata2, format);
+  const filenamePrompt = new Input({
+    name: "filename",
+    message: "Save as:",
+    initial: suggestedFilename
+  });
+  let filename;
+  try {
+    filename = await filenamePrompt.run();
+  } catch {
+    console.log(chalk.gray("Cancelled."));
+    return;
+  }
+  let content;
+  switch (format) {
+    case "md":
+      content = exportToMarkdown(metadata2, messages, options);
+      break;
+    case "json":
+      content = exportToJson(metadata2, messages);
+      break;
+    case "html":
+      content = exportToHtml(metadata2, messages, options);
+      break;
+  }
+  const filePath = path2.isAbsolute(filename) ? filename : path2.join(workspaceRoot, filename);
+  try {
+    await saveExport(content, filePath);
+    console.log();
+    console.log(chalk.green("Session exported successfully!"));
+    console.log(chalk.cyan(`  ${filePath}`));
+    console.log(chalk.gray(`  ${messages.length} messages, ${(Buffer.byteLength(content, "utf8") / 1024).toFixed(1)} KB`));
+    console.log();
+  } catch (error) {
+    console.log(chalk.red(`Failed to save export: ${error.message}`));
+  }
+}
+
+export {
+  metadata,
+  execute
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Session Export
+ * Export sessions to markdown and other formats
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-PQJIQBQ5.js

@@ -0,0 +1,57 @@
+import {
+  getAuthClient,
+  saveConfig
+} from "./chunk-A7HRTONQ.js";
+
+// src/commands/logout.ts
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/logout",
+  description: "sign out of your Autohand account",
+  implemented: true
+};
+async function logout(ctx) {
+  const config = ctx.config;
+  if (!config?.auth?.token) {
+    console.log(chalk.yellow("You are not currently logged in."));
+    console.log(chalk.gray("Use /login to sign in to your Autohand account."));
+    return null;
+  }
+  const userName = config.auth.user?.name || config.auth.user?.email || "user";
+  const { confirm } = await enquirer.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: `Log out from ${chalk.cyan(userName)}?`,
+    initial: true
+  });
+  if (!confirm) {
+    console.log(chalk.gray("Logout cancelled."));
+    return null;
+  }
+  const authClient = getAuthClient();
+  try {
+    await authClient.logout(config.auth.token);
+  } catch {
+  }
+  const updatedConfig = {
+    ...config,
+    auth: void 0
+  };
+  await saveConfig(updatedConfig);
+  console.log();
+  console.log(chalk.green("Successfully logged out."));
+  console.log(chalk.gray("Your local session has been cleared."));
+  console.log();
+  return null;
+}
+
+export {
+  metadata,
+  logout
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-PX5AGAEX.js

@@ -0,0 +1,105 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-2EPIFDFM.js";
+
+// src/commands/agents-new.ts
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/agents new",
+  description: "create a new sub-agent from a description",
+  implemented: true,
+  prd: "prd/sub_agents_architecture.md"
+};
+async function createAgent(ctx) {
+  const answers = await enquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Agent name (e.g., Researcher, QA Tester)",
+      validate: (val) => typeof val === "string" && val.trim() ? true : "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Briefly describe what the agent should do"
+    }
+  ]);
+  const name = answers.name.trim();
+  const description = answers.description.trim();
+  if (!name) {
+    console.log(chalk.gray("Canceled: no name provided."));
+    return null;
+  }
+  const filename = await ensureUniqueFilename(name);
+  const filePath = path.join(getAgentsDir(), filename);
+  const prompt = buildPrompt(name, description);
+  let content;
+  try {
+    const completion = await ctx.llm.complete({
+      messages: [
+        {
+          role: "system",
+          content: "You generate concise markdown definitions for sub-agents. Output only markdown with no code fences. Keep it short but complete."
+        },
+        { role: "user", content: prompt }
+      ],
+      maxTokens: 600
+    });
+    content = completion.content.trim();
+  } catch (error) {
+    console.error(chalk.red(`Failed to generate agent: ${error.message}`));
+    return null;
+  }
+  try {
+    await fs.ensureDir(getAgentsDir());
+    await fs.writeFile(filePath, content + "\n", "utf8");
+    console.log(chalk.green(`Saved new agent to ${filePath}`));
+  } catch (error) {
+    console.error(chalk.red(`Failed to save agent: ${error.message}`));
+    return null;
+  }
+  return null;
+}
+function buildPrompt(name, description) {
+  return [
+    `Create a sub-agent markdown file for "${name}".`,
+    description ? `Agent description: ${description}` : "",
+    "Structure it as:",
+    "# <Name>",
+    "## Purpose",
+    "## Operating Mode (bullet list)",
+    "## Tools (bullet list; mention existing CLI tools and constraints briefly)",
+    "## Output Contract (what to return to main agent)",
+    "Be concise, 120-160 words total."
+  ].filter(Boolean).join("\n");
+}
+function getAgentsDir() {
+  return AUTOHAND_PATHS.agents;
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+async function ensureUniqueFilename(name) {
+  const base = slugify(name);
+  const dir = getAgentsDir();
+  let candidate = `${base}.md`;
+  let counter = 1;
+  while (await fs.pathExists(path.join(dir, candidate))) {
+    candidate = `${base}-${counter}.md`;
+    counter += 1;
+  }
+  return candidate;
+}
+
+export {
+  metadata,
+  createAgent
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-QJ53OSGF.js

@@ -0,0 +1,60 @@
+// src/commands/sessions.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/sessions",
+  description: "list all sessions",
+  implemented: true
+};
+async function sessions(ctx) {
+  const projectFilter = ctx.args.includes("--project") ? ctx.args[ctx.args.indexOf("--project") + 1] : void 0;
+  try {
+    const allSessions = await ctx.sessionManager.listSessions(
+      projectFilter ? { project: projectFilter } : void 0
+    );
+    if (allSessions.length === 0) {
+      console.log(chalk.gray("No sessions found."));
+      return null;
+    }
+    console.log(chalk.cyan(`
+Sessions${projectFilter ? ` for ${projectFilter}` : ""}:
+`));
+    console.log(
+      chalk.bold(
+        " ID".padEnd(25) + "Created".padEnd(20) + "Messages".padEnd(12) + "Summary"
+      )
+    );
+    console.log(chalk.gray("\u2500".repeat(80)));
+    for (const session of allSessions.slice(0, 20)) {
+      const id = session.sessionId.padEnd(24);
+      const created = new Date(session.createdAt).toLocaleString("en-US", {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit"
+      }).padEnd(19);
+      const messages = session.messageCount.toString().padEnd(11);
+      const summary = session.summary?.slice(0, 40) || chalk.gray("No summary");
+      console.log(` ${chalk.cyan(id)}${created}${messages}${summary}`);
+    }
+    if (allSessions.length > 20) {
+      console.log(chalk.gray(`
+... and ${allSessions.length - 20} more sessions`));
+    }
+    console.log(chalk.gray(`
+Use ${chalk.white("/resume <id>")} to continue a session`));
+    return null;
+  } catch (error) {
+    console.error(chalk.red(`Failed to list sessions: ${error.message}`));
+    return null;
+  }
+}
+
+export {
+  metadata,
+  sessions
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-SVLBJMYO.js

@@ -0,0 +1,33 @@
+// src/commands/session.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/session",
+  description: "show the current session details",
+  implemented: true
+};
+async function session(ctx) {
+  const current = ctx.sessionManager.getCurrentSession();
+  if (!current) {
+    console.log(chalk.yellow("No active session."));
+    return null;
+  }
+  const meta = current.metadata;
+  console.log(chalk.cyan("\nCurrent session"));
+  console.log(`${chalk.gray(" ID:")} ${chalk.white(meta.sessionId)}`);
+  console.log(`${chalk.gray(" Project:")} ${chalk.white(meta.projectPath)}`);
+  console.log(`${chalk.gray(" Model:")} ${chalk.white(meta.model)}`);
+  console.log(`${chalk.gray(" Messages:")} ${chalk.white(meta.messageCount.toString())}`);
+  console.log(`${chalk.gray(" Started:")} ${chalk.white(new Date(meta.createdAt).toLocaleString())}`);
+  console.log();
+  return null;
+}
+
+export {
+  metadata,
+  session
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-TAZJSKFD.js

@@ -0,0 +1,57 @@
+// src/commands/memory.ts
+import chalk from "chalk";
+async function memory(ctx) {
+  const { project, user } = await ctx.memoryManager.listAll();
+  console.log();
+  console.log(chalk.bold.cyan("Stored Memories"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  if (project.length === 0 && user.length === 0) {
+    console.log(chalk.gray("No memories stored yet."));
+    console.log();
+    console.log(chalk.gray("Tip: Type # followed by text to store a memory."));
+    console.log(chalk.gray("Example: # Always use TypeScript strict mode"));
+    return null;
+  }
+  if (project.length > 0) {
+    console.log();
+    console.log(chalk.bold.yellow("Project Memories") + chalk.gray(" (.autohand/memory/)"));
+    console.log();
+    for (const entry of project) {
+      const date = new Date(entry.updatedAt).toLocaleDateString();
+      const tags = entry.tags?.length ? chalk.cyan(` [${entry.tags.join(", ")}]`) : "";
+      console.log(chalk.white(`  ${entry.content}`));
+      console.log(chalk.gray(`    ID: ${entry.id} | Updated: ${date}${tags}`));
+      console.log();
+    }
+  }
+  if (user.length > 0) {
+    console.log();
+    console.log(chalk.bold.magenta("User Memories") + chalk.gray(" (~/.autohand/memory/)"));
+    console.log();
+    for (const entry of user) {
+      const date = new Date(entry.updatedAt).toLocaleDateString();
+      const tags = entry.tags?.length ? chalk.cyan(` [${entry.tags.join(", ")}]`) : "";
+      console.log(chalk.white(`  ${entry.content}`));
+      console.log(chalk.gray(`    ID: ${entry.id} | Updated: ${date}${tags}`));
+      console.log();
+    }
+  }
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.gray(`Total: ${project.length} project, ${user.length} user memories`));
+  return null;
+}
+var metadata = {
+  command: "/memory",
+  description: "view stored project and user memories",
+  implemented: true
+};
+
+export {
+  memory,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */