autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-WBU4Q4GS.cjs

@@ -0,0 +1,400 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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/ui/shellCommand.ts
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var DEFAULT_SHELL_TIMEOUT = 3e4;
+var SHELL_HOT_TIP_SUGGESTIONS = [
+  "git status",
+  "ls -la",
+  "bun test",
+  "bun run lint"
+];
+var SHELL_COMMAND_CANDIDATES = [
+  "git",
+  "bun",
+  "npm",
+  "pnpm",
+  "yarn",
+  "node",
+  "python",
+  "python3",
+  "ls",
+  "cd",
+  "mkdir",
+  "cat",
+  "rg",
+  "grep",
+  "find",
+  "touch",
+  "cp",
+  "mv",
+  "rm",
+  "pwd"
+];
+var COMMAND_TEMPLATE_MAP = {
+  git: ["git status", "git diff", "git log --oneline -5"],
+  bun: ["bun test", "bun run lint", "bun run build"],
+  npm: ["npm test", "npm run lint", "npm run build"],
+  pnpm: ["pnpm test", "pnpm lint", "pnpm build"],
+  yarn: ["yarn test", "yarn lint", "yarn build"],
+  ls: ["ls -la"],
+  cd: ["cd ./", "cd .."],
+  mkdir: ["mkdir -p "],
+  rg: ['rg "TODO" src']
+};
+var PATH_COMPLETION_COMMANDS = /* @__PURE__ */ new Set([
+  "cd",
+  "mkdir",
+  "ls",
+  "cat",
+  "rm",
+  "cp",
+  "mv",
+  "touch"
+]);
+var DIRECTORY_ONLY_PATH_COMMANDS = /* @__PURE__ */ new Set(["cd"]);
+var DIR_ENTRIES_CACHE_TTL_MS = 750;
+var dirEntriesCache = /* @__PURE__ */ new Map();
+function unescapeShellSpaces(value) {
+  return value.replace(/\\ /g, " ");
+}
+function escapeShellSpaces(value) {
+  return value.replace(/ /g, "\\ ");
+}
+function unique(items) {
+  return Array.from(new Set(items));
+}
+function getCachedDirectoryEntries(absDir) {
+  const now = Date.now();
+  const cached = dirEntriesCache.get(absDir);
+  if (cached && cached.expiresAt > now) {
+    return cached.entries;
+  }
+  try {
+    const entries = _fs.readdirSync.call(void 0, absDir, { withFileTypes: true });
+    dirEntriesCache.set(absDir, {
+      expiresAt: now + DIR_ENTRIES_CACHE_TTL_MS,
+      entries
+    });
+    return entries;
+  } catch (e) {
+    return [];
+  }
+}
+function completePathToken(rawToken, options = {}) {
+  const cwd = _nullishCoalesce(options.cwd, () => ( process.cwd()));
+  const unescapedToken = unescapeShellSpaces(rawToken);
+  const lastSlash = unescapedToken.lastIndexOf("/");
+  const dirPart = lastSlash >= 0 ? unescapedToken.slice(0, lastSlash + 1) : "";
+  const namePrefix = lastSlash >= 0 ? unescapedToken.slice(lastSlash + 1) : unescapedToken;
+  const directoriesOnly = options.directoriesOnly === true;
+  const searchDirAbs = unescapedToken.startsWith("/") ? _path2.default.resolve(dirPart || "/") : _path2.default.resolve(cwd, dirPart || ".");
+  const matches = getCachedDirectoryEntries(searchDirAbs).filter((entry) => !directoriesOnly || entry.isDirectory()).filter((entry) => entry.name.startsWith(namePrefix)).sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) {
+      return a.isDirectory() ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  return matches.map((entry) => {
+    const suffix = entry.isDirectory() ? "/" : "";
+    const completed = `${dirPart}${entry.name}${suffix}`;
+    return escapeShellSpaces(completed);
+  });
+}
+function parseBangInput(line) {
+  const withoutLeading = line.trimStart();
+  if (!withoutLeading.startsWith("!")) {
+    return null;
+  }
+  const commandBody = withoutLeading.slice(1).trimStart();
+  return {
+    commandBody,
+    hasTrailingSpace: /\s$/.test(line)
+  };
+}
+function buildCommandNameSuggestions(commandPrefix) {
+  const prefix = commandPrefix.toLowerCase();
+  const matches = SHELL_COMMAND_CANDIDATES.filter((candidate) => candidate.startsWith(prefix));
+  const exact = SHELL_COMMAND_CANDIDATES.find((candidate) => candidate === prefix);
+  const suggestions = [];
+  if (exact) {
+    const templates = _nullishCoalesce(COMMAND_TEMPLATE_MAP[exact], () => ( []));
+    suggestions.push(...templates.map((template) => `! ${template}`));
+  }
+  for (const candidate of matches) {
+    suggestions.push(`! ${candidate} `);
+  }
+  return unique(suggestions);
+}
+function buildPathSuggestions(commandName, args, hasTrailingSpace, options = {}) {
+  const normalizedCommand = commandName.toLowerCase();
+  if (!PATH_COMPLETION_COMMANDS.has(normalizedCommand)) {
+    return [];
+  }
+  if (!hasTrailingSpace && args.length > 0 && _optionalChain([args, 'access', _ => _[args.length - 1], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3("-")])) {
+    return [];
+  }
+  const targetIndex = hasTrailingSpace ? args.length : Math.max(0, args.length - 1);
+  const rawToken = hasTrailingSpace ? "" : _nullishCoalesce(args[targetIndex], () => ( ""));
+  const completedTokens = completePathToken(rawToken, {
+    ...options,
+    directoriesOnly: DIRECTORY_ONLY_PATH_COMMANDS.has(normalizedCommand)
+  });
+  const result = [];
+  for (const token of completedTokens) {
+    const nextArgs = [...args];
+    if (hasTrailingSpace) {
+      nextArgs.push(token);
+    } else {
+      nextArgs[targetIndex] = token;
+    }
+    const suggestion = `! ${commandName}${nextArgs.length > 0 ? ` ${nextArgs.join(" ")}` : ""}`;
+    result.push(token.endsWith("/") ? suggestion : `${suggestion} `);
+  }
+  return result;
+}
+function getShellCommandSuggestions(line, options = {}) {
+  const parsed = parseBangInput(line);
+  if (!parsed) {
+    return [];
+  }
+  const { commandBody, hasTrailingSpace } = parsed;
+  const limit = Math.max(1, _nullishCoalesce(options.limit, () => ( 5)));
+  if (!commandBody) {
+    return SHELL_HOT_TIP_SUGGESTIONS.slice(0, limit).map((value) => `! ${value}`);
+  }
+  const tokens = commandBody.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return SHELL_HOT_TIP_SUGGESTIONS.slice(0, limit).map((value) => `! ${value}`);
+  }
+  const commandName = tokens[0];
+  const args = tokens.slice(1);
+  const commandNameSuggestions = !hasTrailingSpace && tokens.length === 1 ? buildCommandNameSuggestions(commandName) : [];
+  const pathSuggestions = buildPathSuggestions(commandName, args, hasTrailingSpace, options);
+  const templates = (_nullishCoalesce(COMMAND_TEMPLATE_MAP[commandName.toLowerCase()], () => ( []))).map((value) => `! ${value}`);
+  const hotTips = SHELL_HOT_TIP_SUGGESTIONS.map((value) => `! ${value}`);
+  return unique([
+    ...pathSuggestions,
+    ...commandNameSuggestions,
+    ...templates,
+    ...hotTips
+  ]).slice(0, limit);
+}
+function getPrimaryShellCommandSuggestion(line, options = {}) {
+  const [first] = getShellCommandSuggestions(line, { ...options, limit: 1 });
+  return _nullishCoalesce(first, () => ( null));
+}
+async function defaultNodePtyLoader() {
+  try {
+    return await Promise.resolve().then(() => _interopRequireWildcard(require("node-pty")));
+  } catch (e2) {
+    return null;
+  }
+}
+var nodePtyLoader = defaultNodePtyLoader;
+function isShellCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("!")) {
+    return false;
+  }
+  const command = trimmed.slice(1).trim();
+  return command.length > 0;
+}
+function parseShellCommand(input) {
+  if (!input.trim().startsWith("!")) {
+    return "";
+  }
+  return input.trim().slice(1).trim();
+}
+function isImmediateCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return false;
+  if (isShellCommand(trimmed)) return true;
+  if (trimmed.startsWith("/")) {
+    const command = trimmed.slice(1).trim();
+    if (command.length === 0) return false;
+    const firstToken = _nullishCoalesce(trimmed.split(/\s+/, 1)[0], () => ( ""));
+    const hasNestedSlashes = (firstToken.match(/\//g) || []).length > 1;
+    const isCommonPathPrefix = /^\/(?:Users|home|tmp|var|opt|etc|usr)\//i.test(firstToken);
+    const looksLikeFile = /\.[a-z0-9]{1,5}$/i.test(firstToken);
+    if (hasNestedSlashes || isCommonPathPrefix || looksLikeFile) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+async function executeShellCommandAsync(command, cwd, timeout = DEFAULT_SHELL_TIMEOUT, options = {}) {
+  const trimmedCommand = command.trim();
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let resolved = false;
+    let timedOut = false;
+    let timeoutId;
+    const finish = (result) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve(result);
+    };
+    let child;
+    try {
+      child = _child_process.spawn.call(void 0, trimmedCommand, {
+        cwd: _nullishCoalesce(cwd, () => ( process.cwd())),
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (error) {
+      const execError = error;
+      finish({
+        success: false,
+        error: _optionalChain([execError, 'access', _4 => _4.stderr, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]) || execError.message || "Unknown error"
+      });
+      return;
+    }
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+      }, timeout);
+    }
+    _optionalChain([child, 'access', _7 => _7.stdout, 'optionalAccess', _8 => _8.on, 'call', _9 => _9("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stdout += text;
+      _optionalChain([options, 'access', _10 => _10.onStdout, 'optionalCall', _11 => _11(text)]);
+    })]);
+    _optionalChain([child, 'access', _12 => _12.stderr, 'optionalAccess', _13 => _13.on, 'call', _14 => _14("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stderr += text;
+      _optionalChain([options, 'access', _15 => _15.onStderr, 'optionalCall', _16 => _16(text)]);
+    })]);
+    child.once("error", (error) => {
+      finish({
+        success: false,
+        error: stderr || _optionalChain([error, 'access', _17 => _17.stderr, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()]) || error.message || "Unknown error"
+      });
+    });
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        finish({
+          success: true,
+          output: stdout
+        });
+        return;
+      }
+      const errorMessage = timedOut ? `Command timed out after ${timeout}ms` : stderr || (signal ? `Command terminated by ${signal}` : `Command failed with exit code ${_nullishCoalesce(code, () => ( "unknown"))}`);
+      finish({
+        success: false,
+        error: errorMessage
+      });
+    });
+  });
+}
+async function loadNodePty() {
+  return nodePtyLoader();
+}
+function getPtyShellLaunch(command) {
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec || "cmd.exe";
+    return {
+      file: comspec,
+      args: ["/d", "/s", "/c", command]
+    };
+  }
+  const shell = process.env.SHELL || "/bin/sh";
+  return {
+    file: shell,
+    args: ["-lc", command]
+  };
+}
+async function executeStreamingShellCommand(command, cwd, options = {}) {
+  const trimmedCommand = command.trim();
+  if (options.background) {
+    return new Promise((resolve) => {
+      let child;
+      try {
+        child = _child_process.spawn.call(void 0, trimmedCommand, {
+          cwd: _nullishCoalesce(cwd, () => ( process.cwd())),
+          shell: true,
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch (error) {
+        const execError = error;
+        resolve({
+          success: false,
+          error: execError.message || "Unknown error"
+        });
+        return;
+      }
+      child.unref();
+      resolve({
+        success: true,
+        output: "",
+        backgroundPid: child.pid
+      });
+    });
+  }
+  const shouldUsePty = options.preferPty === true && process.stdin.isTTY && process.stdout.isTTY;
+  if (!shouldUsePty) {
+    return executeShellCommandAsync(trimmedCommand, cwd, DEFAULT_SHELL_TIMEOUT, options);
+  }
+  const nodePty = await loadNodePty();
+  if (!nodePty) {
+    return executeShellCommandAsync(trimmedCommand, cwd, DEFAULT_SHELL_TIMEOUT, options);
+  }
+  return new Promise((resolve) => {
+    const { file, args } = getPtyShellLaunch(trimmedCommand);
+    const ptyProcess = nodePty.spawn(file, args, {
+      name: process.env.TERM || "xterm-256color",
+      cols: Math.max(20, _nullishCoalesce(_nullishCoalesce(options.columns, () => ( process.stdout.columns)), () => ( 80))),
+      rows: Math.max(10, _nullishCoalesce(_nullishCoalesce(options.rows, () => ( process.stdout.rows)), () => ( 24))),
+      cwd: _nullishCoalesce(cwd, () => ( process.cwd())),
+      env: {
+        ...process.env,
+        AUTOHAND_CLI: "1"
+      }
+    });
+    let output = "";
+    const dataDisposable = ptyProcess.onData((data) => {
+      output += data;
+      _optionalChain([options, 'access', _20 => _20.onStdout, 'optionalCall', _21 => _21(data)]);
+    });
+    const exitDisposable = ptyProcess.onExit((event) => {
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+      const normalized = output.replace(/\r\n/g, "\n");
+      if (event.exitCode === 0) {
+        resolve({
+          success: true,
+          output: normalized
+        });
+        return;
+      }
+      resolve({
+        success: false,
+        error: normalized || `Command failed with exit code ${event.exitCode}`
+      });
+    });
+  });
+}
+
+
+
+
+
+
+
+
+
+exports.getShellCommandSuggestions = getShellCommandSuggestions; exports.getPrimaryShellCommandSuggestion = getPrimaryShellCommandSuggestion; exports.isShellCommand = isShellCommand; exports.parseShellCommand = parseShellCommand; exports.isImmediateCommand = isImmediateCommand; exports.executeShellCommandAsync = executeShellCommandAsync; exports.executeStreamingShellCommand = executeStreamingShellCommand;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-WGLBC5AY.cjs

@@ -0,0 +1,59 @@
+"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(); } }
+
+var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+
+// src/commands/permissions.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+function renderBold(text) {
+  return typeof _chalk2.default.bold === "function" ? _chalk2.default.bold(text) : text;
+}
+function renderSection(title, section) {
+  console.log(renderBold(title));
+  console.log(_chalk2.default.gray(section.path));
+  if (section.allowList.length === 0) {
+    console.log(_chalk2.default.gray("  No AllowList entries"));
+  } else {
+    console.log(_chalk2.default.green("  AllowList"));
+    section.allowList.forEach((pattern, index) => {
+      console.log(_chalk2.default.green(`    ${index + 1}. ${pattern}`));
+    });
+  }
+  if (section.denyList.length === 0) {
+    console.log(_chalk2.default.gray("  No DenyList entries"));
+  } else {
+    console.log(_chalk2.default.red("  DenyList"));
+    section.denyList.forEach((pattern, index) => {
+      console.log(_chalk2.default.red(`    ${index + 1}. ${pattern}`));
+    });
+  }
+  console.log();
+}
+async function permissions(ctx) {
+  const snapshot = ctx.permissionManager.getPermissionSnapshot(_nullishCoalesce(ctx.configPath, () => ( "(user config unknown)")));
+  console.log();
+  console.log(_chalk2.default.bold.cyan(_chunkCHI52KFRcjs.t.call(void 0, "commands.permissions.title")));
+  console.log(_chalk2.default.gray("\u2500".repeat(50)));
+  console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "commands.permissions.mode", { mode: snapshot.mode || "interactive" })));
+  console.log(_chalk2.default.gray(`Remember session decisions: ${snapshot.rememberSession ? "Yes" : "No"}`));
+  console.log();
+  renderSection("Session", snapshot.session);
+  renderSection("Project", snapshot.project);
+  renderSection("User", snapshot.user);
+  renderSection("Effective", snapshot.effective);
+  return null;
+}
+var metadata = {
+  command: "/permissions",
+  description: _chunkCHI52KFRcjs.t.call(void 0, "commands.permissions.description"),
+  implemented: true
+};
+
+
+
+
+exports.permissions = permissions; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-KWXVKLQ5.cjs → chunk-WGNMOVMT.cjs}

@@ -1,17 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
-
-// src/commands/add-dir.ts
-var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
-var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-
-// src/startup/workspaceSafety.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/startup/workspaceSafety.ts
 var _os = require('os'); var _os2 = _interopRequireDefault(_os);
-
-
-
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var DANGEROUS_PATHS = {
   // Filesystem roots (Unix and Windows)
   roots: ["/", "C:\\", "D:\\", "E:\\", "F:\\", "G:\\"],
@@ -65,9 +56,9 @@ function normalizePath(inputPath) {
   }
   return normalized;
 }
-function pathsEqual(path1, path22) {
+function pathsEqual(path1, path2) {
   const normalized1 = normalizePath(path1);
-  const normalized2 = normalizePath(path22);
+  const normalized2 = normalizePath(path2);
   if (process.platform === "darwin" || process.platform === "win32") {
     return normalized1.toLowerCase() === normalized2.toLowerCase();
   }
@@ -260,73 +251,7 @@ function printDangerousWorkspaceWarning(workspacePath, result) {
   console.log();
 }
 
-// src/commands/add-dir.ts
-async function addDir(ctx, args) {
-  const dirPath = args.join(" ").trim();
-  if (!dirPath) {
-    console.log();
-    console.log(_chalk2.default.bold.cyan("Workspace Directories"));
-    console.log(_chalk2.default.gray("\u2500".repeat(50)));
-    console.log();
-    console.log(_chalk2.default.bold("Primary Workspace:"));
-    console.log(_chalk2.default.cyan(`  ${ctx.workspaceRoot}`));
-    console.log();
-    if (ctx.additionalDirs.length > 0) {
-      console.log(_chalk2.default.bold("Additional Directories:"));
-      ctx.additionalDirs.forEach((dir, index) => {
-        console.log(_chalk2.default.green(`  ${index + 1}. ${dir}`));
-      });
-    } else {
-      console.log(_chalk2.default.gray("No additional directories configured."));
-    }
-    console.log();
-    console.log(_chalk2.default.gray("Usage: /add-dir <path> to add a new directory"));
-    console.log();
-    return null;
-  }
-  const resolvedPath = _path2.default.resolve(dirPath);
-  if (!await _fsextra2.default.pathExists(resolvedPath)) {
-    console.log(_chalk2.default.red(_chunk7BTSG4MEcjs.t.call(void 0, "commands.addDir.notFound", { path: dirPath })));
-    return null;
-  }
-  const stats = await _fsextra2.default.stat(resolvedPath);
-  if (!stats.isDirectory()) {
-    console.log(_chalk2.default.red(`Error: Path is not a directory: ${dirPath}`));
-    return null;
-  }
-  const safetyResult = checkWorkspaceSafety(resolvedPath);
-  if (!safetyResult.safe) {
-    console.log(_chalk2.default.red(`Error: Unsafe directory: ${dirPath}`));
-    console.log(_chalk2.default.yellow(`  ${safetyResult.reason}`));
-    return null;
-  }
-  if (resolvedPath === ctx.workspaceRoot) {
-    console.log(_chalk2.default.yellow(`Directory is already the primary workspace: ${resolvedPath}`));
-    return null;
-  }
-  if (ctx.additionalDirs.includes(resolvedPath)) {
-    console.log(_chalk2.default.yellow(_chunk7BTSG4MEcjs.t.call(void 0, "commands.addDir.alreadyAdded", { path: resolvedPath })));
-    return null;
-  }
-  ctx.addAdditionalDir(resolvedPath);
-  console.log(_chalk2.default.green(_chunk7BTSG4MEcjs.t.call(void 0, "commands.addDir.added", { path: resolvedPath })));
-  console.log(_chalk2.default.gray("You can now read, write, and modify files in this directory."));
-  return null;
-}
-var metadata = {
-  command: "/add-dir",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.addDir.description"),
-  implemented: true
-};
-
-
-
 
 
 
-exports.checkWorkspaceSafety = checkWorkspaceSafety; exports.printDangerousWorkspaceWarning = printDangerousWorkspaceWarning; exports.addDir = addDir; exports.metadata = metadata;
-/**
- * @license
- * Copyright 2025 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- */
+exports.checkWorkspaceSafety = checkWorkspaceSafety; exports.printDangerousWorkspaceWarning = printDangerousWorkspaceWarning;