start-command 0.3.1

package/src/lib/substitution.js

@@ -0,0 +1,323 @@
+/**
+ * Substitution Engine for start-command
+ * Parses .lino files and matches natural language commands to shell commands
+ *
+ * Uses Links Notation style patterns with variables like $packageName, $version
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Debug mode from environment
+const DEBUG =
+  process.env.START_DEBUG === '1' || process.env.START_DEBUG === 'true';
+
+/**
+ * Parse a .lino substitutions file
+ * @param {string} filePath - Path to the .lino file
+ * @returns {Array<{pattern: string, replacement: string, regex: RegExp, variables: string[]}>}
+ */
+function parseLinoFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return parseLinoContent(content);
+}
+
+/**
+ * Parse .lino content string
+ * @param {string} content - Content of the .lino file
+ * @returns {Array<{pattern: string, replacement: string, regex: RegExp, variables: string[]}>}
+ */
+function parseLinoContent(content) {
+  const rules = [];
+  const lines = content.split('\n');
+
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+
+    // Skip empty lines and comments
+    if (!line || line.startsWith('#')) {
+      i++;
+      continue;
+    }
+
+    // Look for opening parenthesis of doublet link
+    if (line === '(') {
+      i++;
+
+      // Find the pattern line (first non-empty, non-comment line)
+      let pattern = null;
+      while (i < lines.length) {
+        const patternLine = lines[i].trim();
+        if (
+          patternLine &&
+          !patternLine.startsWith('#') &&
+          patternLine !== ')'
+        ) {
+          pattern = patternLine;
+          i++;
+          break;
+        }
+        i++;
+      }
+
+      // Find the replacement line (second non-empty, non-comment line)
+      let replacement = null;
+      while (i < lines.length) {
+        const replacementLine = lines[i].trim();
+        if (
+          replacementLine &&
+          !replacementLine.startsWith('#') &&
+          replacementLine !== ')'
+        ) {
+          replacement = replacementLine;
+          i++;
+          break;
+        }
+        i++;
+      }
+
+      // Find closing parenthesis
+      while (i < lines.length) {
+        const closeLine = lines[i].trim();
+        if (closeLine === ')') {
+          break;
+        }
+        i++;
+      }
+
+      // Create rule if both pattern and replacement found
+      if (pattern && replacement) {
+        const rule = createRule(pattern, replacement);
+        if (rule) {
+          rules.push(rule);
+        }
+      }
+    }
+
+    i++;
+  }
+
+  return rules;
+}
+
+/**
+ * Create a rule object from pattern and replacement strings
+ * @param {string} pattern - The matching pattern with variables
+ * @param {string} replacement - The replacement pattern
+ * @returns {{pattern: string, replacement: string, regex: RegExp, variables: string[]}|null}
+ */
+function createRule(pattern, replacement) {
+  // Extract variables from pattern (words starting with $)
+  const variables = [];
+  const variablePattern = /\$(\w+)/g;
+  let match;
+
+  while ((match = variablePattern.exec(pattern)) !== null) {
+    variables.push(match[1]);
+  }
+
+  // Convert pattern to regex
+  // First, replace $variables with placeholders
+  let tempPattern = pattern;
+  const placeholders = [];
+
+  for (let i = 0; i < variables.length; i++) {
+    const varName = variables[i];
+    const placeholder = `__VAR_${i}__`;
+    placeholders.push({ placeholder, varName });
+    // Replace first occurrence of this variable
+    tempPattern = tempPattern.replace(`$${varName}`, placeholder);
+  }
+
+  // Escape special regex characters in the remaining text
+  let regexStr = tempPattern.replace(/[.*+?^{}()|[\]\\]/g, '\\$&');
+
+  // Replace placeholders with named capture groups
+  // Use .+? for greedy-enough matching but not too greedy
+  for (const { placeholder, varName } of placeholders) {
+    regexStr = regexStr.replace(placeholder, `(?<${varName}>.+?)`);
+  }
+
+  // Make the regex match the entire string with optional whitespace
+  regexStr = `^\\s*${regexStr}\\s*$`;
+
+  try {
+    const regex = new RegExp(regexStr, 'i'); // Case insensitive
+    return { pattern, replacement, regex, variables };
+  } catch (err) {
+    if (DEBUG) {
+      console.error(`Invalid pattern: ${pattern} - ${err.message}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Sort rules so more specific patterns (more variables, longer patterns) match first
+ * @param {Array} rules - Array of rule objects
+ * @returns {Array} Sorted rules
+ */
+function sortRulesBySpecificity(rules) {
+  return [...rules].sort((a, b) => {
+    // More variables = more specific, should come first
+    if (b.variables.length !== a.variables.length) {
+      return b.variables.length - a.variables.length;
+    }
+    // Longer patterns = more specific
+    return b.pattern.length - a.pattern.length;
+  });
+}
+
+/**
+ * Match input against rules and return the substituted command
+ * @param {string} input - The user input command
+ * @param {Array} rules - Array of rule objects
+ * @returns {{matched: boolean, original: string, command: string, rule: object|null}}
+ */
+function matchAndSubstitute(input, rules) {
+  const trimmedInput = input.trim();
+
+  // Sort rules by specificity (more specific patterns first)
+  const sortedRules = sortRulesBySpecificity(rules);
+
+  for (const rule of sortedRules) {
+    const match = trimmedInput.match(rule.regex);
+
+    if (match) {
+      // Build the substituted command
+      let command = rule.replacement;
+
+      // Replace variables with captured values
+      for (const varName of rule.variables) {
+        const value = match.groups[varName];
+        if (value !== undefined) {
+          command = command.replace(new RegExp(`\\$${varName}`, 'g'), value);
+        }
+      }
+
+      return {
+        matched: true,
+        original: input,
+        command,
+        rule,
+      };
+    }
+  }
+
+  // No match found - return original input
+  return {
+    matched: false,
+    original: input,
+    command: input,
+    rule: null,
+  };
+}
+
+/**
+ * Load default substitutions from the package's substitutions.lino file
+ * @returns {Array} Array of rules
+ */
+function loadDefaultSubstitutions() {
+  // Look for substitutions.lino in the same directory as this file (src/lib)
+  // __dirname is src/lib, substitutions.lino is in the same directory
+  const defaultLinoPath = path.join(__dirname, 'substitutions.lino');
+
+  if (fs.existsSync(defaultLinoPath)) {
+    try {
+      return parseLinoFile(defaultLinoPath);
+    } catch (err) {
+      if (DEBUG) {
+        console.error(`Failed to load default substitutions: ${err.message}`);
+      }
+      return [];
+    }
+  }
+
+  return [];
+}
+
+/**
+ * Load user substitutions from custom path or home directory
+ * @param {string} customPath - Optional custom path to .lino file
+ * @returns {Array} Array of rules
+ */
+function loadUserSubstitutions(customPath) {
+  // If custom path provided, use it
+  if (customPath && fs.existsSync(customPath)) {
+    try {
+      return parseLinoFile(customPath);
+    } catch (err) {
+      if (DEBUG) {
+        console.error(`Failed to load user substitutions: ${err.message}`);
+      }
+      return [];
+    }
+  }
+
+  // Look in home directory for .start-command/substitutions.lino
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  if (homeDir) {
+    const userLinoPath = path.join(
+      homeDir,
+      '.start-command',
+      'substitutions.lino'
+    );
+    if (fs.existsSync(userLinoPath)) {
+      try {
+        return parseLinoFile(userLinoPath);
+      } catch (err) {
+        if (DEBUG) {
+          console.error(`Failed to load user substitutions: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  return [];
+}
+
+/**
+ * Process a command through the substitution engine
+ * @param {string} input - The input command
+ * @param {object} options - Options { customLinoPath, verbose }
+ * @returns {{matched: boolean, original: string, command: string, rule: object|null}}
+ */
+function processCommand(input, options = {}) {
+  const { customLinoPath, verbose } = options;
+
+  // Load rules: user rules take precedence
+  const userRules = loadUserSubstitutions(customLinoPath);
+  const defaultRules = loadDefaultSubstitutions();
+
+  // User rules first, then default rules
+  const allRules = [...userRules, ...defaultRules];
+
+  if (allRules.length === 0) {
+    return {
+      matched: false,
+      original: input,
+      command: input,
+      rule: null,
+    };
+  }
+
+  const result = matchAndSubstitute(input, allRules);
+
+  if (verbose && result.matched) {
+    console.log(`Pattern matched: "${result.rule.pattern}"`);
+    console.log(`Translated to: ${result.command}`);
+  }
+
+  return result;
+}
+
+module.exports = {
+  parseLinoFile,
+  parseLinoContent,
+  createRule,
+  matchAndSubstitute,
+  loadDefaultSubstitutions,
+  loadUserSubstitutions,
+  processCommand,
+};

package/src/lib/substitutions.lino

@@ -0,0 +1,308 @@
+# Substitutions file for start-command
+# Format: Each rule is a doublet link (pattern, replacement)
+# Variables: $packageName, $version, $repository, $url, $path, $branch, etc.
+#
+# This file uses Links Notation style patterns for matching natural language commands
+# and translating them to actual shell commands.
+
+# === NPM Package Installation ===
+
+# install {packageName} npm package
+(
+  install $packageName npm package
+  npm install $packageName
+)
+
+# install {version} version of {packageName} npm package
+(
+  install $version version of $packageName npm package
+  npm install $packageName@$version
+)
+
+# install {packageName} npm package globally
+(
+  install $packageName npm package globally
+  npm install -g $packageName
+)
+
+# install {packageName} globally
+(
+  install $packageName globally
+  npm install -g $packageName
+)
+
+# install {version} version of {packageName} npm package globally
+(
+  install $version version of $packageName npm package globally
+  npm install -g $packageName@$version
+)
+
+# uninstall {packageName} npm package
+(
+  uninstall $packageName npm package
+  npm uninstall $packageName
+)
+
+# uninstall {packageName} npm package globally
+(
+  uninstall $packageName npm package globally
+  npm uninstall -g $packageName
+)
+
+# remove {packageName} npm package
+(
+  remove $packageName npm package
+  npm uninstall $packageName
+)
+
+# update {packageName} npm package
+(
+  update $packageName npm package
+  npm update $packageName
+)
+
+# === Git Repository Operations ===
+
+# clone {repository} repository
+(
+  clone $repository repository
+  git clone $repository
+)
+
+# clone {url}
+(
+  clone $url
+  git clone $url
+)
+
+# clone {repository} repository to {path}
+(
+  clone $repository repository to $path
+  git clone $repository $path
+)
+
+# clone {repository} repository into {path}
+(
+  clone $repository repository into $path
+  git clone $repository $path
+)
+
+# checkout {branch} branch
+(
+  checkout $branch branch
+  git checkout $branch
+)
+
+# create {branch} branch
+(
+  create $branch branch
+  git checkout -b $branch
+)
+
+# switch to {branch} branch
+(
+  switch to $branch branch
+  git checkout $branch
+)
+
+# push to {remote}
+(
+  push to $remote
+  git push $remote
+)
+
+# push to {remote} {branch}
+(
+  push to $remote $branch
+  git push $remote $branch
+)
+
+# pull from {remote}
+(
+  pull from $remote
+  git pull $remote
+)
+
+# pull from {remote} {branch}
+(
+  pull from $remote $branch
+  git pull $remote $branch
+)
+
+# === Common Operations ===
+
+# list files
+(
+  list files
+  ls -la
+)
+
+# list files in {path}
+(
+  list files in $path
+  ls -la $path
+)
+
+# show current directory
+(
+  show current directory
+  pwd
+)
+
+# show working directory
+(
+  show working directory
+  pwd
+)
+
+# create {name} directory
+(
+  create $name directory
+  mkdir -p $name
+)
+
+# create directory {name}
+(
+  create directory $name
+  mkdir -p $name
+)
+
+# remove {name} directory
+(
+  remove $name directory
+  rm -rf $name
+)
+
+# delete {name} directory
+(
+  delete $name directory
+  rm -rf $name
+)
+
+# remove {name} file
+(
+  remove $name file
+  rm $name
+)
+
+# delete {name} file
+(
+  delete $name file
+  rm $name
+)
+
+# show {file} contents
+(
+  show $file contents
+  cat $file
+)
+
+# read {file}
+(
+  read $file
+  cat $file
+)
+
+# === Process/System Operations ===
+
+# show running processes
+(
+  show running processes
+  ps aux
+)
+
+# find process {name}
+(
+  find process $name
+  ps aux | grep $name
+)
+
+# kill process {pid}
+(
+  kill process $pid
+  kill $pid
+)
+
+# === Docker Operations ===
+
+# list docker containers
+(
+  list docker containers
+  docker ps
+)
+
+# list all docker containers
+(
+  list all docker containers
+  docker ps -a
+)
+
+# start {container} container
+(
+  start $container container
+  docker start $container
+)
+
+# stop {container} container
+(
+  stop $container container
+  docker stop $container
+)
+
+# remove {container} container
+(
+  remove $container container
+  docker rm $container
+)
+
+# build docker image from {path}
+(
+  build docker image from $path
+  docker build $path
+)
+
+# build docker image {name} from {path}
+(
+  build docker image $name from $path
+  docker build -t $name $path
+)
+
+# === Python/Pip Operations ===
+
+# install {packageName} python package
+(
+  install $packageName python package
+  pip install $packageName
+)
+
+# install {packageName} pip package
+(
+  install $packageName pip package
+  pip install $packageName
+)
+
+# install {version} version of {packageName} python package
+(
+  install $version version of $packageName python package
+  pip install $packageName==$version
+)
+
+# uninstall {packageName} python package
+(
+  uninstall $packageName python package
+  pip uninstall $packageName
+)
+
+# === Help Patterns ===
+
+# show help
+(
+  show help
+  $ --help
+)
+
+# help
+(
+  help
+  $ --help
+)