autohand-cli 0.6.3 → 0.6.4

package/dist/chunk-KNLBEUAV.cjs

@@ -0,0 +1,57 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/commands/memory.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+async function memory(ctx) {
+  const { project, user } = await ctx.memoryManager.listAll();
+  console.log();
+  console.log(_chalk2.default.bold.cyan("Stored Memories"));
+  console.log(_chalk2.default.gray("\u2500".repeat(50)));
+  if (project.length === 0 && user.length === 0) {
+    console.log(_chalk2.default.gray("No memories stored yet."));
+    console.log();
+    console.log(_chalk2.default.gray("Tip: Type # followed by text to store a memory."));
+    console.log(_chalk2.default.gray("Example: # Always use TypeScript strict mode"));
+    return null;
+  }
+  if (project.length > 0) {
+    console.log();
+    console.log(_chalk2.default.bold.yellow("Project Memories") + _chalk2.default.gray(" (.autohand/memory/)"));
+    console.log();
+    for (const entry of project) {
+      const date = new Date(entry.updatedAt).toLocaleDateString();
+      const tags = _optionalChain([entry, 'access', _ => _.tags, 'optionalAccess', _2 => _2.length]) ? _chalk2.default.cyan(` [${entry.tags.join(", ")}]`) : "";
+      console.log(_chalk2.default.white(`  ${entry.content}`));
+      console.log(_chalk2.default.gray(`    ID: ${entry.id} | Updated: ${date}${tags}`));
+      console.log();
+    }
+  }
+  if (user.length > 0) {
+    console.log();
+    console.log(_chalk2.default.bold.magenta("User Memories") + _chalk2.default.gray(" (~/.autohand/memory/)"));
+    console.log();
+    for (const entry of user) {
+      const date = new Date(entry.updatedAt).toLocaleDateString();
+      const tags = _optionalChain([entry, 'access', _3 => _3.tags, 'optionalAccess', _4 => _4.length]) ? _chalk2.default.cyan(` [${entry.tags.join(", ")}]`) : "";
+      console.log(_chalk2.default.white(`  ${entry.content}`));
+      console.log(_chalk2.default.gray(`    ID: ${entry.id} | Updated: ${date}${tags}`));
+      console.log();
+    }
+  }
+  console.log(_chalk2.default.gray("\u2500".repeat(50)));
+  console.log(_chalk2.default.gray(`Total: ${project.length} project, ${user.length} user memories`));
+  return null;
+}
+var metadata = {
+  command: "/memory",
+  description: "view stored project and user memories",
+  implemented: true
+};
+
+
+
+
+exports.memory = memory; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-M4LKQQHU.cjs

@@ -0,0 +1,168 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkIHJDYAYJcjs = require('./chunk-IHJDYAYJ.cjs');
+
+// src/auth/AuthClient.ts
+var DEFAULT_TIMEOUT = 1e4;
+var AuthClient = class {
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || _chunkIHJDYAYJcjs.AUTH_CONFIG.apiBaseUrl;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+  /**
+   * Initiate device authorization flow
+   * Returns device code and user code for display
+   */
+  async initiateDeviceAuth() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/cli/initiate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ clientId: "autohand-cli" }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || data.message || `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: true,
+        deviceCode: data.deviceCode,
+        userCode: data.userCode,
+        verificationUri: data.verificationUri,
+        verificationUriComplete: data.verificationUriComplete,
+        expiresIn: data.expiresIn,
+        interval: data.interval
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        return { success: false, error: "Request timeout" };
+      }
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Poll for device authorization status
+   */
+  async pollDeviceAuth(deviceCode) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/cli/poll`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ deviceCode }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok && response.status !== 404) {
+        return {
+          success: false,
+          status: "pending",
+          error: data.error || data.message || `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: data.success !== false,
+        status: data.status || "pending",
+        token: data.token,
+        user: data.user,
+        error: data.error
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        return { success: false, status: "pending", error: "Request timeout" };
+      }
+      return { success: false, status: "pending", error: error.message };
+    }
+  }
+  /**
+   * Validate current session token
+   */
+  async validateSession(token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/me`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Cookie": `auth_session=${token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return { authenticated: false };
+      }
+      const data = await response.json();
+      return {
+        authenticated: true,
+        user: data.user || data
+      };
+    } catch (e) {
+      clearTimeout(timeoutId);
+      return { authenticated: false };
+    }
+  }
+  /**
+   * Logout and invalidate session
+   */
+  async logout(token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/logout`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Cookie": `auth_session=${token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return { success: response.ok };
+    } catch (e2) {
+      clearTimeout(timeoutId);
+      return { success: true };
+    }
+  }
+};
+var instance = null;
+function getAuthClient(config) {
+  if (!instance) {
+    instance = new AuthClient(config);
+  }
+  return instance;
+}
+
+
+
+exports.getAuthClient = getAuthClient;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auth API Client for CLI authentication
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auth module exports
+ */

package/dist/chunk-M7RVTUWE.cjs

@@ -0,0 +1,145 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/commands/lint.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+
+// src/actions/linters.ts
+var _child_process = require('child_process');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+var LINTERS = {
+  eslint: {
+    name: "eslint",
+    command: "eslint",
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"],
+    description: "Pluggable JavaScript/TypeScript linter",
+    checkCmd: ["eslint", "--version"]
+  },
+  pylint: {
+    name: "pylint",
+    command: "pylint",
+    extensions: [".py"],
+    description: "Python static code analysis tool",
+    checkCmd: ["pylint", "--version"]
+  },
+  ruff: {
+    name: "ruff",
+    command: "ruff",
+    extensions: [".py"],
+    description: "Extremely fast Python linter (recommended)",
+    checkCmd: ["ruff", "--version"]
+  },
+  clippy: {
+    name: "clippy",
+    command: "cargo",
+    extensions: [".rs"],
+    description: "Rust linter with helpful suggestions",
+    checkCmd: ["cargo", "clippy", "--version"]
+  },
+  golangci: {
+    name: "golangci-lint",
+    command: "golangci-lint",
+    extensions: [".go"],
+    description: "Fast Go linter aggregator",
+    checkCmd: ["golangci-lint", "--version"]
+  },
+  shellcheck: {
+    name: "shellcheck",
+    command: "shellcheck",
+    extensions: [".sh", ".bash"],
+    description: "Shell script static analysis tool",
+    checkCmd: ["shellcheck", "--version"]
+  },
+  stylelint: {
+    name: "stylelint",
+    command: "stylelint",
+    extensions: [".css", ".scss", ".less"],
+    description: "CSS linter",
+    checkCmd: ["stylelint", "--version"]
+  },
+  htmlhint: {
+    name: "htmlhint",
+    command: "htmlhint",
+    extensions: [".html", ".htm"],
+    description: "HTML linter",
+    checkCmd: ["htmlhint", "--version"]
+  }
+};
+async function isCommandAvailable(command, args = ["--version"]) {
+  return new Promise((resolve) => {
+    const proc = _child_process.spawn.call(void 0, command, args, {
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    proc.on("error", () => resolve(false));
+    proc.on("close", (code) => resolve(code === 0));
+    setTimeout(() => {
+      proc.kill();
+      resolve(false);
+    }, 3e3);
+  });
+}
+async function checkAvailableLinters() {
+  const results = {};
+  const checks = Object.entries(LINTERS).map(async ([name, info]) => {
+    if (name === "clippy") {
+      results[name] = await isCommandAvailable("cargo", ["clippy", "--version"]);
+    } else {
+      results[name] = await isCommandAvailable(info.command);
+    }
+  });
+  await Promise.all(checks);
+  return results;
+}
+async function listLinters() {
+  const available = await checkAvailableLinters();
+  return Object.entries(LINTERS).map(([name, info]) => ({
+    ...info,
+    installed: _nullishCoalesce(available[name], () => ( false))
+  }));
+}
+
+// src/commands/lint.ts
+var metadata = {
+  command: "/lint",
+  description: "List available code linters",
+  implemented: true
+};
+async function execute() {
+  console.log();
+  console.log(_chalk2.default.cyan.bold("Available Code Linters"));
+  console.log(_chalk2.default.gray("\u2500".repeat(60)));
+  console.log();
+  const linters = await listLinters();
+  for (const linter of linters) {
+    const status = linter.installed ? _chalk2.default.green("\u2713 installed") : _chalk2.default.red("\u2717 not found");
+    console.log(`  ${linter.installed ? _chalk2.default.green("\u2713") : _chalk2.default.red("\u2717")} ${_chalk2.default.white.bold(linter.name)} ${_chalk2.default.gray(`(${linter.command})`)} - ${status}`);
+    console.log(`    ${_chalk2.default.gray(linter.description)}`);
+    console.log(`    ${_chalk2.default.gray("Extensions:")} ${linter.extensions.join(", ")}`);
+    console.log();
+  }
+  console.log(_chalk2.default.gray("\u2500".repeat(60)));
+  console.log(_chalk2.default.gray("Usage: The agent can use lint_file action to check code quality."));
+  console.log(_chalk2.default.gray("Install missing linters via your package manager:"));
+  console.log(_chalk2.default.gray("  npm: npm install -g eslint stylelint"));
+  console.log(_chalk2.default.gray("  pip: pip install pylint ruff"));
+  console.log(_chalk2.default.gray("  cargo: rustup component add clippy"));
+  console.log(_chalk2.default.gray("  go: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"));
+  console.log();
+}
+
+
+
+
+exports.metadata = metadata; exports.execute = execute;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Code Linters
+ * Supports eslint, pylint, clippy, golangci-lint, and more
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-MFK6HE47.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/session.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_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(_chalk2.default.yellow("No active session."));
+    return null;
+  }
+  const meta = current.metadata;
+  console.log(_chalk2.default.cyan("\nCurrent session"));
+  console.log(`${_chalk2.default.gray(" ID:")} ${_chalk2.default.white(meta.sessionId)}`);
+  console.log(`${_chalk2.default.gray(" Project:")} ${_chalk2.default.white(meta.projectPath)}`);
+  console.log(`${_chalk2.default.gray(" Model:")} ${_chalk2.default.white(meta.model)}`);
+  console.log(`${_chalk2.default.gray(" Messages:")} ${_chalk2.default.white(meta.messageCount.toString())}`);
+  console.log(`${_chalk2.default.gray(" Started:")} ${_chalk2.default.white(new Date(meta.createdAt).toLocaleString())}`);
+  console.log();
+  return null;
+}
+
+
+
+
+exports.metadata = metadata; exports.session = session;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-N254NRHT.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+
+
+
+exports.__commonJS = __commonJS; exports.__toESM = __toESM;