autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-26G7YGOW.js

@@ -0,0 +1,367 @@
+import {
+  package_default
+} from "./chunk-JB3JCYBJ.js";
+import {
+  showModal
+} from "./chunk-NZ3ZWLUW.js";
+import {
+  saveConfig
+} from "./chunk-IEPLQ47J.js";
+import {
+  formatFeatureList,
+  formatFeatureStatus,
+  getFeatureState,
+  isLocalFeatureId,
+  listFeatureStates,
+  setFeatureState
+} from "./chunk-LANGD5CO.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-SHRLFX6F.js";
+
+// src/features/RemoteFeatureFlagManager.ts
+import crypto from "crypto";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+var FEATURE_FLAG_REQUEST_TIMEOUT_MS = 1500;
+function getApiBaseUrl(config) {
+  return (config.api?.baseUrl || config.telemetry?.apiBaseUrl || "https://api.autohand.ai").replace(/\/+$/, "");
+}
+function readDeviceId() {
+  try {
+    fs.ensureDirSync(path.dirname(AUTOHAND_FILES.deviceId));
+    if (fs.existsSync(AUTOHAND_FILES.deviceId)) {
+      const existing = fs.readFileSync(AUTOHAND_FILES.deviceId, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = crypto.randomUUID();
+    fs.writeFileSync(AUTOHAND_FILES.deviceId, next);
+    return next;
+  } catch {
+    return crypto.randomUUID();
+  }
+}
+function parseSnapshot(value) {
+  if (value.success !== true || !Array.isArray(value.flags)) return null;
+  const flags = [];
+  for (const flag of value.flags) {
+    if (!flag || typeof flag !== "object") continue;
+    const candidate = flag;
+    if (typeof candidate.key !== "string" || typeof candidate.enabled !== "boolean") continue;
+    flags.push({
+      key: candidate.key,
+      enabled: candidate.enabled,
+      reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
+      userOverridable: candidate.userOverridable !== false
+    });
+  }
+  return {
+    success: true,
+    environment: typeof value.environment === "string" ? value.environment : "production",
+    flags,
+    evaluatedAt: typeof value.evaluatedAt === "string" ? value.evaluatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    ttlSeconds: typeof value.ttlSeconds === "number" ? value.ttlSeconds : 300
+  };
+}
+function isSnapshotFresh(snapshot) {
+  const evaluatedAt = Date.parse(snapshot.evaluatedAt);
+  if (Number.isNaN(evaluatedAt)) return false;
+  const ttlMs = Math.max(0, snapshot.ttlSeconds) * 1e3;
+  return Date.now() - evaluatedAt < ttlMs;
+}
+function createEvaluationUrl(config, deviceId, clientVersion) {
+  const environment = config.features?.environment || "production";
+  const url = new URL(`${getApiBaseUrl(config)}/v1/feature-flags/evaluate`);
+  url.searchParams.set("environment", environment);
+  url.searchParams.set("clientType", "cli");
+  url.searchParams.set("deviceId", deviceId);
+  url.searchParams.set("cliVersion", clientVersion);
+  url.searchParams.set("platform", process.platform);
+  return url;
+}
+async function downloadRemoteFeatureFlags(config, deviceId, clientVersion) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FEATURE_FLAG_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetch(createEvaluationUrl(config, deviceId, clientVersion), { signal: controller.signal });
+    if (!response.ok) return null;
+    return parseSnapshot(await response.json());
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function writeRemoteFeatureFlagCache(snapshot) {
+  await fs.ensureDir(path.dirname(AUTOHAND_FILES.featureFlagsCache));
+  await fs.writeJson(AUTOHAND_FILES.featureFlagsCache, snapshot, { spaces: 2 });
+}
+async function loadCachedRemoteFeatureFlags() {
+  try {
+    if (!await fs.pathExists(AUTOHAND_FILES.featureFlagsCache)) {
+      return null;
+    }
+    const data = await fs.readJson(AUTOHAND_FILES.featureFlagsCache);
+    return parseSnapshot(data);
+  } catch {
+    return null;
+  }
+}
+async function loadRemoteFeatureFlags(config, options = {}) {
+  const cached = await loadCachedRemoteFeatureFlags();
+  if (!options.forceRefresh && cached && isSnapshotFresh(cached)) {
+    return cached;
+  }
+  const downloaded = await downloadRemoteFeatureFlags(config, readDeviceId(), package_default.version);
+  if (downloaded) {
+    await writeRemoteFeatureFlagCache(downloaded);
+    return downloaded;
+  }
+  return options.allowCachedFallback === false ? null : cached;
+}
+var RemoteFeatureFlagManager = class {
+  constructor(config) {
+    this.config = config;
+    this.apiBaseUrl = getApiBaseUrl(config);
+    this.environment = config.features?.environment || "production";
+    this.clientVersion = package_default.version;
+  }
+  config;
+  snapshot = null;
+  deviceId = readDeviceId();
+  apiBaseUrl;
+  environment;
+  clientVersion;
+  async refreshFeatureFlags() {
+    const downloaded = await downloadRemoteFeatureFlags(this.config, this.deviceId, this.clientVersion);
+    if (downloaded) {
+      this.snapshot = downloaded;
+      await writeRemoteFeatureFlagCache(downloaded);
+      return;
+    }
+    this.snapshot = await loadCachedRemoteFeatureFlags();
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  isFeatureEnabled(key, localDefault = false) {
+    if (isLocalFeatureId(key)) {
+      return localDefault;
+    }
+    const flag = this.snapshot?.flags.find((item) => item.key === key);
+    if (!flag) return localDefault;
+    if (!flag.enabled) return false;
+    return this.config.features?.remoteOverrides?.[key] !== "off";
+  }
+  async trackFeatureActivation(key, metadata2) {
+    void metadata2;
+    const flag = this.snapshot?.flags.find((item) => item.key === key);
+    if (!flag || !this.isFeatureEnabled(key)) return;
+    try {
+      await fetch(`${this.apiBaseUrl}/v1/feature-flags/events`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          events: [{
+            key,
+            environment: this.environment,
+            eventType: "activation",
+            enabled: true,
+            reason: flag.reason,
+            deviceId: this.deviceId,
+            clientType: "cli",
+            cliVersion: this.clientVersion,
+            platform: process.platform,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }]
+        })
+      });
+    } catch {
+    }
+  }
+  getStatus() {
+    return {
+      apiBaseUrl: this.apiBaseUrl,
+      environment: this.environment,
+      deviceId: this.deviceId,
+      platform: process.platform,
+      osVersion: os.release(),
+      evaluatedAt: this.snapshot?.evaluatedAt || null
+    };
+  }
+};
+
+// src/commands/features.ts
+function renderUsage() {
+  return [
+    "Usage: /features [list|status|enable|disable|refresh]",
+    "",
+    "Commands:",
+    "  /features",
+    "  /features list",
+    "  /features status <feature>",
+    "  /features enable <feature>",
+    "  /features disable <feature>",
+    "  /features refresh"
+  ].join("\n");
+}
+function requireConfig(config) {
+  return config ?? "Config not available.";
+}
+async function setFeatureEnabled(config, featureId, enabled, remoteSnapshot) {
+  if (!featureId) {
+    return renderUsage();
+  }
+  const snapshot = remoteSnapshot === void 0 ? await loadRemoteFeatureFlags(config) : remoteSnapshot;
+  const result = setFeatureState(config, featureId, enabled, { remoteSnapshot: snapshot });
+  if (!result.ok || !result.feature) {
+    return result.error ?? `Unknown feature "${featureId}".`;
+  }
+  await saveConfig(config);
+  if (result.feature.source === "remote") {
+    if (enabled) {
+      return `Following remote state for ${result.feature.id} (currently ${result.feature.enabled ? "on" : "off"}).`;
+    }
+    return `Disabled ${result.feature.id} locally. Remote state remains ${result.feature.remoteEnabled ? "on" : "off"}.`;
+  }
+  const action = enabled ? "Enabled" : "Disabled";
+  const restartNote = result.feature.requiresRestart ? " Restart Autohand for this to fully apply." : "";
+  return `${action} ${result.feature.id}.${restartNote}`;
+}
+async function showInteractiveFeatures(config, remoteSnapshot) {
+  let toggleCount = 0;
+  const pendingSaves = [];
+  const states = listFeatureStates(config, { remoteSnapshot });
+  const initialStates = new Map(states.map((feature) => [feature.id, feature.enabled]));
+  const finalStates = new Map(initialStates);
+  const restartRequired = new Set(states.filter((feature) => feature.requiresRestart).map((feature) => feature.id));
+  const options = states.map((feature) => ({
+    label: `${feature.id.padEnd(26)} ${feature.source.padEnd(8)} ${feature.stage.padEnd(12)} ${feature.enabled ? "on" : "off"}`,
+    value: feature.id,
+    checked: feature.enabled,
+    description: feature.description
+  }));
+  await showModal({
+    title: "Features - space toggles, enter closes",
+    options,
+    multiSelect: true,
+    maxVisible: 12,
+    onToggle: (option, checked) => {
+      const result = setFeatureState(config, option.value, checked, { remoteSnapshot });
+      if (!result.ok) {
+        return;
+      }
+      toggleCount += 1;
+      finalStates.set(option.value, result.feature?.enabled ?? checked);
+      pendingSaves.push(saveConfig(config));
+    }
+  });
+  await Promise.all(pendingSaves);
+  if (toggleCount === 0) {
+    return null;
+  }
+  const enabled = [];
+  const disabled = [];
+  for (const [featureId, initiallyEnabled] of initialStates) {
+    const finallyEnabled = finalStates.get(featureId);
+    if (finallyEnabled === initiallyEnabled || typeof finallyEnabled !== "boolean") {
+      continue;
+    }
+    if (finallyEnabled) {
+      enabled.push(featureId);
+    } else {
+      disabled.push(featureId);
+    }
+  }
+  return formatInteractiveFeatureSummary({
+    enabled,
+    disabled,
+    restartRequired: [...new Set([...enabled, ...disabled].filter((featureId) => restartRequired.has(featureId)))]
+  });
+}
+function formatChangedFeatures(action, featureIds) {
+  if (featureIds.length === 0) {
+    return null;
+  }
+  if (featureIds.length === 1) {
+    return `${action} ${featureIds[0]}.`;
+  }
+  return `${action} ${featureIds.length} features: ${featureIds.join(", ")}.`;
+}
+function formatInteractiveFeatureSummary(changes) {
+  const parts = [
+    formatChangedFeatures("Enabled", changes.enabled),
+    formatChangedFeatures("Disabled", changes.disabled)
+  ].filter((part) => Boolean(part));
+  if (changes.restartRequired.length > 0) {
+    parts.push(`Restart required for: ${changes.restartRequired.join(", ")}.`);
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+async function features(ctx, args = []) {
+  const required = requireConfig(ctx.config);
+  if (typeof required === "string") {
+    return required;
+  }
+  const subcommand = (args[0] ?? "").toLowerCase();
+  const featureId = args[1];
+  const forceRefresh = subcommand === "refresh";
+  const remoteSnapshot = await loadRemoteFeatureFlags(required, {
+    forceRefresh,
+    allowCachedFallback: !forceRefresh
+  });
+  switch (subcommand) {
+    case "":
+      return showInteractiveFeatures(required, remoteSnapshot);
+    case "list":
+    case "ls":
+      if (ctx.interactive) {
+        return showInteractiveFeatures(required, remoteSnapshot);
+      }
+      return formatFeatureList(required, { remoteSnapshot });
+    case "status":
+    case "show":
+      return featureId ? formatFeatureStatus(required, featureId, { remoteSnapshot }) : renderUsage();
+    case "enable":
+    case "on":
+      return setFeatureEnabled(required, featureId, true, remoteSnapshot);
+    case "disable":
+    case "off":
+      return setFeatureEnabled(required, featureId, false, remoteSnapshot);
+    case "refresh":
+      if (!remoteSnapshot) {
+        return "No remote feature flags available. Using local feature switches only.";
+      }
+      return `Downloaded ${remoteSnapshot.flags.length} remote feature${remoteSnapshot.flags.length === 1 ? "" : "s"} from ${remoteSnapshot.environment}.`;
+    default:
+      if (getFeatureState(required, subcommand, { remoteSnapshot })) {
+        return formatFeatureStatus(required, subcommand, { remoteSnapshot });
+      }
+      return renderUsage();
+  }
+}
+var metadata = {
+  command: "/features",
+  description: "list and toggle Autohand feature switches",
+  implemented: true,
+  subcommands: [
+    { name: "list", description: "List feature switches and current state" },
+    { name: "status", description: "Show one feature switch" },
+    { name: "enable", description: "Enable a feature switch" },
+    { name: "disable", description: "Disable a feature switch" },
+    { name: "refresh", description: "Download remote feature flags from the Autohand API" }
+  ]
+};
+
+export {
+  RemoteFeatureFlagManager,
+  setFeatureEnabled,
+  features,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-3L53OA4E.cjs → chunk-2ESQR35E.cjs}

@@ -2,10 +2,10 @@
 
 
 
-var _chunkZYQMLKOKcjs = require('./chunk-ZYQMLKOK.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
 
 
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/export.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
@@ -245,7 +245,7 @@ function getSuggestedFilename(metadata2, format) {
 // src/commands/export.ts
 var metadata = {
   command: "/export",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.export.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.export.description"),
   implemented: true
 };
 async function execute(args, context) {
@@ -265,7 +265,7 @@ async function execute(args, context) {
       label: `${s.projectName} - ${new Date(s.createdAt).toLocaleString()} (${s.messageCount} messages)`,
       value: s.sessionId
     }));
-    const sessionResult = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
+    const sessionResult = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
       title: "Select a session to export:",
       options: sessionOptions
     });
@@ -286,7 +286,7 @@ async function execute(args, context) {
     { label: "JSON (.json)", value: "json" },
     { label: "HTML (.html)", value: "html" }
   ];
-  const formatResult = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
+  const formatResult = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
     title: "Export format:",
     options: formatOptions
   });
@@ -297,17 +297,17 @@ async function execute(args, context) {
   const format = formatResult.value;
   const options = {};
   if (format === "md" || format === "html") {
-    options.includeToolOutputs = await _chunkZYQMLKOKcjs.showConfirm.call(void 0, {
+    options.includeToolOutputs = await _chunkCK4HAHVYcjs.showConfirm.call(void 0, {
       title: "Include tool outputs?",
       defaultValue: true
     });
-    options.includeToc = await _chunkZYQMLKOKcjs.showConfirm.call(void 0, {
+    options.includeToc = await _chunkCK4HAHVYcjs.showConfirm.call(void 0, {
       title: "Include table of contents?",
       defaultValue: false
     });
   }
   const suggestedFilename = getSuggestedFilename(metadata2, format);
-  const filename = await _chunkZYQMLKOKcjs.showInput.call(void 0, {
+  const filename = await _chunkCK4HAHVYcjs.showInput.call(void 0, {
     title: "Save as:",
     defaultValue: suggestedFilename
   });
@@ -331,11 +331,11 @@ async function execute(args, context) {
   try {
     await saveExport(content, filePath);
     console.log();
-    console.log(_chalk2.default.green(_chunk7BTSG4MEcjs.t.call(void 0, "commands.export.success", { path: filePath })));
+    console.log(_chalk2.default.green(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.export.success", { path: filePath })));
     console.log(_chalk2.default.gray(`  ${messages.length} messages, ${(Buffer.byteLength(content, "utf8") / 1024).toFixed(1)} KB`));
     console.log();
   } catch (error) {
-    console.log(_chalk2.default.red(_chunk7BTSG4MEcjs.t.call(void 0, "commands.export.failed", { error: error.message })));
+    console.log(_chalk2.default.red(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.export.failed", { error: error.message })));
   }
 }
 

package/dist/chunk-2H5O745H.js

@@ -0,0 +1,63 @@
+// src/commands/pr-review.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/pr-review",
+  description: "review a pull request using gh metadata and diff context",
+  implemented: true
+};
+function buildPrompt(workspaceRoot, prSelector, additionalFocus) {
+  const ghViewCommand = prSelector ? `gh pr view ${prSelector}` : "gh pr view <number>";
+  const ghDiffCommand = prSelector ? `gh pr diff ${prSelector}` : "gh pr diff <number>";
+  const parts = [
+    "You are a staff-level pull request reviewer.",
+    "",
+    "## Pull Request Review Target",
+    `Workspace: ${workspaceRoot}`,
+    prSelector ? `PR selector: ${prSelector}` : "PR selector: not provided",
+    "",
+    "## Review Workflow",
+    "1. Confirm this is a GitHub repository and that the GitHub CLI is available.",
+    "2. If no PR selector is provided, run `gh pr list` and choose the most relevant open pull request before continuing.",
+    `3. Run \`${ghViewCommand}\` to gather PR metadata, changed files, title, base branch, and status.`,
+    `4. Run \`${ghDiffCommand}\` to inspect the actual patch before reviewing.`,
+    "5. Use repository tools such as `read_file`, `fff_grep`, `fff_find`, `git_diff`, and `git_status` to inspect the touched code paths in detail.",
+    "",
+    "## Review Output",
+    "Deliver findings first, ordered by severity, with concrete file references when possible.",
+    "Focus on correctness, regressions, missing tests, performance, security, and maintainability.",
+    "Keep the summary brief and only include it after the findings."
+  ];
+  if (additionalFocus) {
+    parts.push("", "## Additional Focus", additionalFocus);
+  }
+  return parts.join("\n");
+}
+async function prReview(ctx, args = []) {
+  const [firstArg, ...restArgs] = args;
+  const prSelector = firstArg?.trim() ?? "";
+  const additionalFocus = restArgs.join(" ").trim();
+  const prompt = buildPrompt(ctx.workspaceRoot, prSelector, additionalFocus);
+  if (ctx.isNonInteractive || !ctx.queueInstruction) {
+    return prompt;
+  }
+  ctx.queueInstruction(prompt);
+  console.log(chalk.cyan("\n  Starting pull request review..."));
+  if (prSelector) {
+    console.log(chalk.gray(`  PR selector: ${prSelector}`));
+  }
+  if (additionalFocus) {
+    console.log(chalk.gray(`  Focus: ${additionalFocus}`));
+  }
+  console.log(chalk.gray("  Gathering GitHub metadata and diff context before reviewing.\n"));
+  return null;
+}
+
+export {
+  metadata,
+  prReview
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */