lcclaude 1.0.0

package/dist/src/utils/bash/shellQuote.js

@@ -0,0 +1,159 @@
+import {
+  parse as shellQuoteParse,
+  quote as shellQuoteQuote
+} from "shell-quote";
+import { logError } from "../log.js";
+import { jsonStringify } from "../slowOperations.js";
+export function tryParseShellCommand(cmd, env) {
+  try {
+    const tokens = typeof env === "function" ? shellQuoteParse(cmd, env) : shellQuoteParse(cmd, env);
+    return { success: true, tokens };
+  } catch (error) {
+    if (error instanceof Error) {
+      logError(error);
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown parse error"
+    };
+  }
+}
+export function tryQuoteShellArgs(args) {
+  try {
+    const validated = args.map((arg, index) => {
+      if (arg === null || arg === undefined) {
+        return String(arg);
+      }
+      const type = typeof arg;
+      if (type === "string") {
+        return arg;
+      }
+      if (type === "number" || type === "boolean") {
+        return String(arg);
+      }
+      if (type === "object") {
+        throw new Error(`Cannot quote argument at index ${index}: object values are not supported`);
+      }
+      if (type === "symbol") {
+        throw new Error(`Cannot quote argument at index ${index}: symbol values are not supported`);
+      }
+      if (type === "function") {
+        throw new Error(`Cannot quote argument at index ${index}: function values are not supported`);
+      }
+      throw new Error(`Cannot quote argument at index ${index}: unsupported type ${type}`);
+    });
+    const quoted = shellQuoteQuote(validated);
+    return { success: true, quoted };
+  } catch (error) {
+    if (error instanceof Error) {
+      logError(error);
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown quote error"
+    };
+  }
+}
+export function hasMalformedTokens(command, parsed) {
+  let inSingle = false;
+  let inDouble = false;
+  let doubleCount = 0;
+  let singleCount = 0;
+  for (let i = 0;i < command.length; i++) {
+    const c = command[i];
+    if (c === "\\" && !inSingle) {
+      i++;
+      continue;
+    }
+    if (c === '"' && !inSingle) {
+      doubleCount++;
+      inDouble = !inDouble;
+    } else if (c === "'" && !inDouble) {
+      singleCount++;
+      inSingle = !inSingle;
+    }
+  }
+  if (doubleCount % 2 !== 0 || singleCount % 2 !== 0)
+    return true;
+  for (const entry of parsed) {
+    if (typeof entry !== "string")
+      continue;
+    const openBraces = (entry.match(/{/g) || []).length;
+    const closeBraces = (entry.match(/}/g) || []).length;
+    if (openBraces !== closeBraces)
+      return true;
+    const openParens = (entry.match(/\(/g) || []).length;
+    const closeParens = (entry.match(/\)/g) || []).length;
+    if (openParens !== closeParens)
+      return true;
+    const openBrackets = (entry.match(/\[/g) || []).length;
+    const closeBrackets = (entry.match(/\]/g) || []).length;
+    if (openBrackets !== closeBrackets)
+      return true;
+    const doubleQuotes = entry.match(/(?<!\\)"/g) || [];
+    if (doubleQuotes.length % 2 !== 0)
+      return true;
+    const singleQuotes = entry.match(/(?<!\\)'/g) || [];
+    if (singleQuotes.length % 2 !== 0)
+      return true;
+  }
+  return false;
+}
+export function hasShellQuoteSingleQuoteBug(command) {
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = 0;i < command.length; i++) {
+    const char = command[i];
+    if (char === "\\" && !inSingleQuote) {
+      i++;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      if (!inSingleQuote) {
+        let backslashCount = 0;
+        let j = i - 1;
+        while (j >= 0 && command[j] === "\\") {
+          backslashCount++;
+          j--;
+        }
+        if (backslashCount > 0 && backslashCount % 2 === 1) {
+          return true;
+        }
+        if (backslashCount > 0 && backslashCount % 2 === 0 && command.indexOf("'", i + 1) !== -1) {
+          return true;
+        }
+      }
+      continue;
+    }
+  }
+  return false;
+}
+export function quote(args) {
+  const result = tryQuoteShellArgs([...args]);
+  if (result.success) {
+    return result.quoted;
+  }
+  try {
+    const stringArgs = args.map((arg) => {
+      if (arg === null || arg === undefined) {
+        return String(arg);
+      }
+      const type = typeof arg;
+      if (type === "string" || type === "number" || type === "boolean") {
+        return String(arg);
+      }
+      return jsonStringify(arg);
+    });
+    return shellQuoteQuote(stringArgs);
+  } catch (error) {
+    if (error instanceof Error) {
+      logError(error);
+    }
+    throw new Error("Failed to quote shell arguments safely");
+  }
+}

package/dist/src/utils/bash/shellQuoting.js

@@ -0,0 +1,43 @@
+import { quote } from "./shellQuote.js";
+function containsHeredoc(command) {
+  if (/\d\s*<<\s*\d/.test(command) || /\[\[\s*\d+\s*<<\s*\d+\s*\]\]/.test(command) || /\$\(\(.*<<.*\)\)/.test(command)) {
+    return false;
+  }
+  const heredocRegex = /<<-?\s*(?:(['"]?)(\w+)\1|\\(\w+))/;
+  return heredocRegex.test(command);
+}
+function containsMultilineString(command) {
+  const singleQuoteMultiline = /'(?:[^'\\]|\\.)*\n(?:[^'\\]|\\.)*'/;
+  const doubleQuoteMultiline = /"(?:[^"\\]|\\.)*\n(?:[^"\\]|\\.)*"/;
+  return singleQuoteMultiline.test(command) || doubleQuoteMultiline.test(command);
+}
+export function quoteShellCommand(command, addStdinRedirect = true) {
+  if (containsHeredoc(command) || containsMultilineString(command)) {
+    const escaped = command.replace(/'/g, `'"'"'`);
+    const quoted = `'${escaped}'`;
+    if (containsHeredoc(command)) {
+      return quoted;
+    }
+    return addStdinRedirect ? `${quoted} < /dev/null` : quoted;
+  }
+  if (addStdinRedirect) {
+    return quote([command, "<", "/dev/null"]);
+  }
+  return quote([command]);
+}
+export function hasStdinRedirect(command) {
+  return /(?:^|[\s;&|])<(?![<(])\s*\S+/.test(command);
+}
+export function shouldAddStdinRedirect(command) {
+  if (containsHeredoc(command)) {
+    return false;
+  }
+  if (hasStdinRedirect(command)) {
+    return false;
+  }
+  return true;
+}
+const NUL_REDIRECT_REGEX = /(\d?&?>+\s*)[Nn][Uu][Ll](?=\s|$|[|&;)\n])/g;
+export function rewriteWindowsNullRedirect(command) {
+  return command.replace(NUL_REDIRECT_REGEX, "$1/dev/null");
+}

package/dist/src/utils/bash/specs/alias.js

@@ -0,0 +1,11 @@
+const alias = {
+  name: "alias",
+  description: "Create or list command aliases",
+  args: {
+    name: "definition",
+    description: "Alias definition in the form name=value",
+    isOptional: true,
+    isVariadic: true
+  }
+};
+export default alias;

package/dist/src/utils/bash/specs/index.js

@@ -0,0 +1,16 @@
+import alias from "./alias.js";
+import nohup from "./nohup.js";
+import pyright from "./pyright.js";
+import sleep from "./sleep.js";
+import srun from "./srun.js";
+import time from "./time.js";
+import timeout from "./timeout.js";
+export default [
+  pyright,
+  timeout,
+  sleep,
+  alias,
+  nohup,
+  time,
+  srun
+];

package/dist/src/utils/bash/specs/nohup.js

@@ -0,0 +1,10 @@
+const nohup = {
+  name: "nohup",
+  description: "Run a command immune to hangups",
+  args: {
+    name: "command",
+    description: "Command to run with nohup",
+    isCommand: true
+  }
+};
+export default nohup;

package/dist/src/utils/bash/specs/pyright.js

@@ -0,0 +1,88 @@
+export default {
+  name: "pyright",
+  description: "Type checker for Python",
+  options: [
+    { name: ["--help", "-h"], description: "Show help message" },
+    { name: "--version", description: "Print pyright version and exit" },
+    {
+      name: ["--watch", "-w"],
+      description: "Continue to run and watch for changes"
+    },
+    {
+      name: ["--project", "-p"],
+      description: "Use the configuration file at this location",
+      args: { name: "FILE OR DIRECTORY" }
+    },
+    { name: "-", description: "Read file or directory list from stdin" },
+    {
+      name: "--createstub",
+      description: "Create type stub file(s) for import",
+      args: { name: "IMPORT" }
+    },
+    {
+      name: ["--typeshedpath", "-t"],
+      description: "Use typeshed type stubs at this location",
+      args: { name: "DIRECTORY" }
+    },
+    {
+      name: "--verifytypes",
+      description: "Verify completeness of types in py.typed package",
+      args: { name: "IMPORT" }
+    },
+    {
+      name: "--ignoreexternal",
+      description: "Ignore external imports for --verifytypes"
+    },
+    {
+      name: "--pythonpath",
+      description: "Path to the Python interpreter",
+      args: { name: "FILE" }
+    },
+    {
+      name: "--pythonplatform",
+      description: "Analyze for platform",
+      args: { name: "PLATFORM" }
+    },
+    {
+      name: "--pythonversion",
+      description: "Analyze for Python version",
+      args: { name: "VERSION" }
+    },
+    {
+      name: ["--venvpath", "-v"],
+      description: "Directory that contains virtual environments",
+      args: { name: "DIRECTORY" }
+    },
+    { name: "--outputjson", description: "Output results in JSON format" },
+    { name: "--verbose", description: "Emit verbose diagnostics" },
+    { name: "--stats", description: "Print detailed performance stats" },
+    {
+      name: "--dependencies",
+      description: "Emit import dependency information"
+    },
+    {
+      name: "--level",
+      description: "Minimum diagnostic level",
+      args: { name: "LEVEL" }
+    },
+    {
+      name: "--skipunannotated",
+      description: "Skip type analysis of unannotated functions"
+    },
+    {
+      name: "--warnings",
+      description: "Use exit code of 1 if warnings are reported"
+    },
+    {
+      name: "--threads",
+      description: "Use up to N threads to parallelize type checking",
+      args: { name: "N", isOptional: true }
+    }
+  ],
+  args: {
+    name: "files",
+    description: "Specify files or directories to analyze (overrides config file)",
+    isVariadic: true,
+    isOptional: true
+  }
+};

package/dist/src/utils/bash/specs/sleep.js

@@ -0,0 +1,10 @@
+const sleep = {
+  name: "sleep",
+  description: "Delay for a specified amount of time",
+  args: {
+    name: "duration",
+    description: "Duration to sleep (seconds or with suffix like 5s, 2m, 1h)",
+    isOptional: false
+  }
+};
+export default sleep;

package/dist/src/utils/bash/specs/srun.js

@@ -0,0 +1,28 @@
+const srun = {
+  name: "srun",
+  description: "Run a command on SLURM cluster nodes",
+  options: [
+    {
+      name: ["-n", "--ntasks"],
+      description: "Number of tasks",
+      args: {
+        name: "count",
+        description: "Number of tasks to run"
+      }
+    },
+    {
+      name: ["-N", "--nodes"],
+      description: "Number of nodes",
+      args: {
+        name: "count",
+        description: "Number of nodes to allocate"
+      }
+    }
+  ],
+  args: {
+    name: "command",
+    description: "Command to run on the cluster",
+    isCommand: true
+  }
+};
+export default srun;

package/dist/src/utils/bash/specs/time.js

@@ -0,0 +1,10 @@
+const time = {
+  name: "time",
+  description: "Time a command",
+  args: {
+    name: "command",
+    description: "Command to time",
+    isCommand: true
+  }
+};
+export default time;

package/dist/src/utils/bash/specs/timeout.js

@@ -0,0 +1,17 @@
+const timeout = {
+  name: "timeout",
+  description: "Run a command with a time limit",
+  args: [
+    {
+      name: "duration",
+      description: "Duration to wait before timing out (e.g., 10, 5s, 2m)",
+      isOptional: false
+    },
+    {
+      name: "command",
+      description: "Command to run",
+      isCommand: true
+    }
+  ]
+};
+export default timeout;

package/dist/src/utils/bash/treeSitterAnalysis.js

@@ -0,0 +1,259 @@
+function collectQuoteSpans(node, out, inDouble) {
+  switch (node.type) {
+    case "raw_string":
+      out.raw.push([node.startIndex, node.endIndex]);
+      return;
+    case "ansi_c_string":
+      out.ansiC.push([node.startIndex, node.endIndex]);
+      return;
+    case "string":
+      if (!inDouble)
+        out.double.push([node.startIndex, node.endIndex]);
+      for (const child of node.children) {
+        if (child)
+          collectQuoteSpans(child, out, true);
+      }
+      return;
+    case "heredoc_redirect": {
+      let isQuoted = false;
+      for (const child of node.children) {
+        if (child && child.type === "heredoc_start") {
+          const first = child.text[0];
+          isQuoted = first === "'" || first === '"' || first === "\\";
+          break;
+        }
+      }
+      if (isQuoted) {
+        out.heredoc.push([node.startIndex, node.endIndex]);
+        return;
+      }
+      break;
+    }
+  }
+  for (const child of node.children) {
+    if (child)
+      collectQuoteSpans(child, out, inDouble);
+  }
+}
+function buildPositionSet(spans) {
+  const set = new Set;
+  for (const [start, end] of spans) {
+    for (let i = start;i < end; i++) {
+      set.add(i);
+    }
+  }
+  return set;
+}
+function dropContainedSpans(spans) {
+  return spans.filter((s, i) => !spans.some((other, j) => j !== i && other[0] <= s[0] && other[1] >= s[1] && (other[0] < s[0] || other[1] > s[1])));
+}
+function removeSpans(command, spans) {
+  if (spans.length === 0)
+    return command;
+  const sorted = dropContainedSpans(spans).sort((a, b) => b[0] - a[0]);
+  let result = command;
+  for (const [start, end] of sorted) {
+    result = result.slice(0, start) + result.slice(end);
+  }
+  return result;
+}
+function replaceSpansKeepQuotes(command, spans) {
+  if (spans.length === 0)
+    return command;
+  const sorted = dropContainedSpans(spans).sort((a, b) => b[0] - a[0]);
+  let result = command;
+  for (const [start, end, open, close] of sorted) {
+    result = result.slice(0, start) + open + close + result.slice(end);
+  }
+  return result;
+}
+export function extractQuoteContext(rootNode, command) {
+  const spans = { raw: [], ansiC: [], double: [], heredoc: [] };
+  collectQuoteSpans(rootNode, spans, false);
+  const singleQuoteSpans = spans.raw;
+  const ansiCSpans = spans.ansiC;
+  const doubleQuoteSpans = spans.double;
+  const quotedHeredocSpans = spans.heredoc;
+  const allQuoteSpans = [
+    ...singleQuoteSpans,
+    ...ansiCSpans,
+    ...doubleQuoteSpans,
+    ...quotedHeredocSpans
+  ];
+  const singleQuoteSet = buildPositionSet([
+    ...singleQuoteSpans,
+    ...ansiCSpans,
+    ...quotedHeredocSpans
+  ]);
+  const doubleQuoteDelimSet = new Set;
+  for (const [start, end] of doubleQuoteSpans) {
+    doubleQuoteDelimSet.add(start);
+    doubleQuoteDelimSet.add(end - 1);
+  }
+  let withDoubleQuotes = "";
+  for (let i = 0;i < command.length; i++) {
+    if (singleQuoteSet.has(i))
+      continue;
+    if (doubleQuoteDelimSet.has(i))
+      continue;
+    withDoubleQuotes += command[i];
+  }
+  const fullyUnquoted = removeSpans(command, allQuoteSpans);
+  const spansWithQuoteChars = [];
+  for (const [start, end] of singleQuoteSpans) {
+    spansWithQuoteChars.push([start, end, "'", "'"]);
+  }
+  for (const [start, end] of ansiCSpans) {
+    spansWithQuoteChars.push([start, end, "$'", "'"]);
+  }
+  for (const [start, end] of doubleQuoteSpans) {
+    spansWithQuoteChars.push([start, end, '"', '"']);
+  }
+  for (const [start, end] of quotedHeredocSpans) {
+    spansWithQuoteChars.push([start, end, "", ""]);
+  }
+  const unquotedKeepQuoteChars = replaceSpansKeepQuotes(command, spansWithQuoteChars);
+  return { withDoubleQuotes, fullyUnquoted, unquotedKeepQuoteChars };
+}
+export function extractCompoundStructure(rootNode, command) {
+  const n = rootNode;
+  const operators = [];
+  const segments = [];
+  let hasSubshell = false;
+  let hasCommandGroup = false;
+  let hasPipeline = false;
+  function walkTopLevel(node) {
+    for (const child of node.children) {
+      if (!child)
+        continue;
+      if (child.type === "list") {
+        for (const listChild of child.children) {
+          if (!listChild)
+            continue;
+          if (listChild.type === "&&" || listChild.type === "||") {
+            operators.push(listChild.type);
+          } else if (listChild.type === "list" || listChild.type === "redirected_statement") {
+            walkTopLevel({ ...node, children: [listChild] });
+          } else if (listChild.type === "pipeline") {
+            hasPipeline = true;
+            segments.push(listChild.text);
+          } else if (listChild.type === "subshell") {
+            hasSubshell = true;
+            segments.push(listChild.text);
+          } else if (listChild.type === "compound_statement") {
+            hasCommandGroup = true;
+            segments.push(listChild.text);
+          } else {
+            segments.push(listChild.text);
+          }
+        }
+      } else if (child.type === ";") {
+        operators.push(";");
+      } else if (child.type === "pipeline") {
+        hasPipeline = true;
+        segments.push(child.text);
+      } else if (child.type === "subshell") {
+        hasSubshell = true;
+        segments.push(child.text);
+      } else if (child.type === "compound_statement") {
+        hasCommandGroup = true;
+        segments.push(child.text);
+      } else if (child.type === "command" || child.type === "declaration_command" || child.type === "variable_assignment") {
+        segments.push(child.text);
+      } else if (child.type === "redirected_statement") {
+        let foundInner = false;
+        for (const inner of child.children) {
+          if (!inner || inner.type === "file_redirect")
+            continue;
+          foundInner = true;
+          walkTopLevel({ ...child, children: [inner] });
+        }
+        if (!foundInner) {
+          segments.push(child.text);
+        }
+      } else if (child.type === "negated_command") {
+        segments.push(child.text);
+        walkTopLevel(child);
+      } else if (child.type === "if_statement" || child.type === "while_statement" || child.type === "for_statement" || child.type === "case_statement" || child.type === "function_definition") {
+        segments.push(child.text);
+        walkTopLevel(child);
+      }
+    }
+  }
+  walkTopLevel(n);
+  if (segments.length === 0) {
+    segments.push(command);
+  }
+  return {
+    hasCompoundOperators: operators.length > 0,
+    hasPipeline,
+    hasSubshell,
+    hasCommandGroup,
+    operators,
+    segments
+  };
+}
+export function hasActualOperatorNodes(rootNode) {
+  const n = rootNode;
+  function walk(node) {
+    if (node.type === ";" || node.type === "&&" || node.type === "||") {
+      return true;
+    }
+    if (node.type === "list") {
+      return true;
+    }
+    for (const child of node.children) {
+      if (child && walk(child))
+        return true;
+    }
+    return false;
+  }
+  return walk(n);
+}
+export function extractDangerousPatterns(rootNode) {
+  const n = rootNode;
+  let hasCommandSubstitution = false;
+  let hasProcessSubstitution = false;
+  let hasParameterExpansion = false;
+  let hasHeredoc = false;
+  let hasComment = false;
+  function walk(node) {
+    switch (node.type) {
+      case "command_substitution":
+        hasCommandSubstitution = true;
+        break;
+      case "process_substitution":
+        hasProcessSubstitution = true;
+        break;
+      case "expansion":
+        hasParameterExpansion = true;
+        break;
+      case "heredoc_redirect":
+        hasHeredoc = true;
+        break;
+      case "comment":
+        hasComment = true;
+        break;
+    }
+    for (const child of node.children) {
+      if (child)
+        walk(child);
+    }
+  }
+  walk(n);
+  return {
+    hasCommandSubstitution,
+    hasProcessSubstitution,
+    hasParameterExpansion,
+    hasHeredoc,
+    hasComment
+  };
+}
+export function analyzeCommand(rootNode, command) {
+  return {
+    quoteContext: extractQuoteContext(rootNode, command),
+    compoundStructure: extractCompoundStructure(rootNode, command),
+    hasActualOperatorNodes: hasActualOperatorNodes(rootNode),
+    dangerousPatterns: extractDangerousPatterns(rootNode)
+  };
+}