@rmrdeveloper/sideroom-pi 8.1.0 → 8.2.0

package/extensions/done/detect.ts

@@ -7,6 +7,21 @@ export interface CheckCommand {
   readonly display: string;
 }
 
+const SHELL_OPERATOR = {
+  and: '&&',
+  or: '||',
+  pipe: '|',
+  sequence: ';',
+  background: '&',
+} as const;
+
+type ShellOperator = (typeof SHELL_OPERATOR)[keyof typeof SHELL_OPERATOR];
+
+interface ShellSegment {
+  readonly text: string;
+  readonly operatorBefore: ShellOperator | undefined;
+}
+
 export const PACKAGE_MANAGER = {
   npm: 'npm',
   pnpm: 'pnpm',
@@ -48,14 +63,98 @@ export function detectCheckCommand(cwd: string): CheckCommand | undefined {
 }
 
 export function commandMatches(text: string, check: CheckCommand): boolean {
-  const normalized = collapseWhitespace(text.trim());
   const target = collapseWhitespace(check.display);
+  const segments = splitShellCommand(text);
+  const hasUnsafeOperator = segments.some(
+    ({ operatorBefore }) =>
+      operatorBefore !== undefined && operatorBefore !== SHELL_OPERATOR.and,
+  );
+  if (hasUnsafeOperator) {
+    return false;
+  }
+
+  return segments.some(({ text: segmentText }) =>
+    simpleCommandMatches(segmentText, target),
+  );
+}
+
+function simpleCommandMatches(text: string, target: string): boolean {
+  const normalized = collapseWhitespace(text.trim());
   if (normalized === target) {
     return true;
   }
-  return [' ', '&', '|', ';'].some((separator) =>
-    normalized.startsWith(`${target}${separator}`),
-  );
+  return normalized.startsWith(`${target} `);
+}
+
+function splitShellCommand(commandText: string): ShellSegment[] {
+  const segments: ShellSegment[] = [];
+  let segmentStart = 0;
+  let operatorBefore: ShellOperator | undefined;
+  let quote = '';
+
+  for (let index = 0; index < commandText.length; index += 1) {
+    const character = commandText[index] ?? '';
+    if (quote.length > 0) {
+      if (character === '\\' && quote === '"') {
+        index += 1;
+        continue;
+      }
+      if (character === quote) {
+        quote = '';
+      }
+      continue;
+    }
+
+    const startsQuote =
+      character === "'" || character === '"' || character === '`';
+    if (startsQuote) {
+      quote = character;
+      continue;
+    }
+
+    const operator = shellOperatorAt(commandText, index);
+    if (operator === undefined) {
+      continue;
+    }
+    segments.push({
+      text: commandText.slice(segmentStart, index),
+      operatorBefore,
+    });
+    operatorBefore = operator;
+    index += operator.length - 1;
+    segmentStart = index + 1;
+  }
+
+  segments.push({
+    text: commandText.slice(segmentStart),
+    operatorBefore,
+  });
+  return segments;
+}
+
+function shellOperatorAt(
+  commandText: string,
+  index: number,
+): ShellOperator | undefined {
+  const twoCharacterOperator = commandText.slice(index, index + 2);
+  if (twoCharacterOperator === SHELL_OPERATOR.and) {
+    return SHELL_OPERATOR.and;
+  }
+  if (twoCharacterOperator === SHELL_OPERATOR.or) {
+    return SHELL_OPERATOR.or;
+  }
+
+  const character = commandText[index];
+  if (character === SHELL_OPERATOR.pipe) {
+    return SHELL_OPERATOR.pipe;
+  }
+  if (character === SHELL_OPERATOR.sequence) {
+    return SHELL_OPERATOR.sequence;
+  }
+  if (character === SHELL_OPERATOR.background) {
+    return SHELL_OPERATOR.background;
+  }
+  return undefined;
 }
 
 function detectPackageCommand(cwd: string): CheckCommand | undefined {

package/extensions/guidelines/catalog.ts

@@ -21,6 +21,7 @@ export interface LanguageGuide {
 export const LANGUAGE_GUIDES: readonly LanguageGuide[] = [
   languageGuide('go.md', ['.go']),
   languageGuide('java.md', ['.java']),
+  languageGuide('javascript.md', ['.js', '.jsx', '.mjs', '.cjs']),
   languageGuide('php-laravel.md', ['.php']),
   languageGuide('python.md', ['.py']),
   languageGuide('rust.md', ['.rs']),

package/extensions/rules/checks.ts

@@ -5,12 +5,12 @@ import {
   type RuleId,
   supportsBracedConditionals,
 } from './catalog.ts';
+import { maskNonCode } from './lexer.ts';
 import type { AddedLine, RuleViolation } from './model.ts';
 
 const BANNED_ALTERNATION = 'data|info|temp|tmp|result|obj|val|x';
-
-const BRACED_IF = /\b(?:if|else\s+if|for|while)\s*\(.*\)\s*(?!\{)\S/;
-const BRACED_ELSE = /\belse\s+(?!if\b|\{)\S/;
+const CONTROL_HEADER = /\b(?:if|else\s+if|for|while)\s*\(/g;
+const ELSE_KEYWORD = /\belse\b/g;
 const PYTHON_INLINE_SUITE =
   /^\s*(?:if|elif|else|for|while|with|try|except|finally|def|class)\b.*:\s*(?:return|pass|raise|break|continue|yield|assert|del|import|from|global|nonlocal|print|await|lambda)\b/;
 
@@ -50,19 +50,33 @@ export function evaluateAddedLines(
   lines: readonly AddedLine[],
 ): RuleViolation[] {
   const violations: RuleViolation[] = [];
+  const joined = lines.map((added) => added.text).join('\n');
+  const code = maskNonCode(joined, language);
+  const codeLines = code.split('\n');
+  const usesBracedConditionals = supportsBracedConditionals(language);
+
+  if (usesBracedConditionals) {
+    collectBracedConditionals(code, lines, violations);
+  }
 
-  for (const added of lines) {
-    if (supportsBracedConditionals(language)) {
-      collectBracedConditionals(added, violations);
-    } else if (language === LANGUAGE.python) {
-      collectPythonSuite(added, violations);
+  for (let index = 0; index < lines.length; index += 1) {
+    const added = lines[index];
+    if (added === undefined) {
+      continue;
+    }
+    const codeLine: AddedLine = {
+      line: added.line,
+      text: codeLines[index] ?? '',
+    };
+    if (language === LANGUAGE.python) {
+      collectPythonSuite(codeLine, violations);
     }
-    collectClearNames(added, violations);
+    collectClearNames(codeLine, violations);
     collectComments(added, violations);
-    collectDebugArtifacts(added, violations);
+    collectDebugArtifacts(codeLine, violations);
   }
 
-  collectErrorHandling(language, lines, violations);
+  collectErrorHandling(language, code, lines, violations);
   return dedupe(violations);
 }
 
@@ -75,15 +89,60 @@ function violation(
 }
 
 function collectBracedConditionals(
-  added: AddedLine,
+  code: string,
+  lines: readonly AddedLine[],
   violations: RuleViolation[],
 ): void {
-  if (BRACED_IF.test(added.text) || BRACED_ELSE.test(added.text)) {
+  const controlMatcher = new RegExp(
+    CONTROL_HEADER.source,
+    CONTROL_HEADER.flags,
+  );
+  const controlMatches = code.matchAll(controlMatcher);
+  for (const match of controlMatches) {
+    const matchOffset = match.index ?? 0;
+    const openingOffset = code.indexOf('(', matchOffset);
+    if (openingOffset < 0) {
+      continue;
+    }
+    const closingOffset = closingParenthesisOffset(code, openingOffset);
+    if (closingOffset === undefined) {
+      continue;
+    }
+    const bodyOffset = nextCodeOffset(code, closingOffset + 1);
+    if (bodyOffset === undefined) {
+      continue;
+    }
+    const hasBlockBody = code[bodyOffset] === '{';
+    if (hasBlockBody) {
+      continue;
+    }
     violations.push(
       violation(
         'braced-conditionals',
         '[braced-conditionals] Wrap the conditional body in braces.',
-        added.line,
+        lineForOffset(code, lines, matchOffset),
+      ),
+    );
+  }
+
+  const elseMatcher = new RegExp(ELSE_KEYWORD.source, ELSE_KEYWORD.flags);
+  const elseMatches = code.matchAll(elseMatcher);
+  for (const match of elseMatches) {
+    const matchOffset = match.index ?? 0;
+    const bodyOffset = nextCodeOffset(code, matchOffset + match[0].length);
+    if (bodyOffset === undefined) {
+      continue;
+    }
+    const hasBlockBody = code[bodyOffset] === '{';
+    const hasNestedIf = startsWithWord(code, bodyOffset, 'if');
+    if (hasBlockBody || hasNestedIf) {
+      continue;
+    }
+    violations.push(
+      violation(
+        'braced-conditionals',
+        '[braced-conditionals] Wrap the conditional body in braces.',
+        lineForOffset(code, lines, matchOffset),
       ),
     );
   }
@@ -106,20 +165,20 @@ function collectPythonSuite(
 
 function collectErrorHandling(
   language: LanguageId,
+  code: string,
   lines: readonly AddedLine[],
   violations: RuleViolation[],
 ): void {
-  const joined = lines.map((added) => added.text).join('\n');
   if (language === LANGUAGE.python) {
-    collectPattern(PYTHON_SWALLOW, joined, lines, violations);
-    collectPattern(PYTHON_SWALLOW_BLOCK, joined, lines, violations);
+    collectPattern(PYTHON_SWALLOW, code, lines, violations);
+    collectPattern(PYTHON_SWALLOW_BLOCK, code, lines, violations);
     return;
   }
   if (language === LANGUAGE.generic) {
     return;
   }
-  collectPattern(EMPTY_CATCH, joined, lines, violations);
-  collectPattern(SWALLOW_RETURN, joined, lines, violations);
+  collectPattern(EMPTY_CATCH, code, lines, violations);
+  collectPattern(SWALLOW_RETURN, code, lines, violations);
 }
 
 function collectPattern(
@@ -215,6 +274,49 @@ function collectDebugArtifacts(
   }
 }
 
+function closingParenthesisOffset(
+  code: string,
+  openingOffset: number,
+): number | undefined {
+  let depth = 0;
+  for (let index = openingOffset; index < code.length; index += 1) {
+    const character = code[index];
+    if (character === '(') {
+      depth += 1;
+      continue;
+    }
+    if (character !== ')') {
+      continue;
+    }
+    depth -= 1;
+    if (depth === 0) {
+      return index;
+    }
+  }
+  return undefined;
+}
+
+function nextCodeOffset(code: string, offset: number): number | undefined {
+  for (let index = offset; index < code.length; index += 1) {
+    const character = code[index] ?? '';
+    const isWhitespace = /\s/.test(character);
+    if (!isWhitespace) {
+      return index;
+    }
+  }
+  return undefined;
+}
+
+function startsWithWord(code: string, offset: number, word: string): boolean {
+  const startsAtOffset = code.startsWith(word, offset);
+  if (!startsAtOffset) {
+    return false;
+  }
+  const following = code[offset + word.length] ?? '';
+  const isWordCharacter = /[A-Za-z0-9_$]/.test(following);
+  return following.length === 0 || !isWordCharacter;
+}
+
 function lineForOffset(
   joined: string,
   lines: readonly AddedLine[],

package/extensions/rules/lexer.ts

@@ -0,0 +1,136 @@
+import { LANGUAGE, type LanguageId } from './catalog.ts';
+
+const LEXICAL_MODE = {
+  code: 'code',
+  lineComment: 'line-comment',
+  blockComment: 'block-comment',
+  string: 'string',
+} as const;
+
+type LexicalMode = (typeof LEXICAL_MODE)[keyof typeof LEXICAL_MODE];
+
+export function maskNonCode(source: string, language: LanguageId): string {
+  const masked = [...source];
+  let mode: LexicalMode = LEXICAL_MODE.code;
+  let delimiter = '';
+
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index] ?? '';
+
+    if (mode === LEXICAL_MODE.lineComment) {
+      if (character === '\n') {
+        mode = LEXICAL_MODE.code;
+        continue;
+      }
+      maskCharacter(masked, index);
+      continue;
+    }
+
+    if (mode === LEXICAL_MODE.blockComment) {
+      const closesComment = character === '*' && source[index + 1] === '/';
+      if (closesComment) {
+        maskCharacter(masked, index);
+        maskCharacter(masked, index + 1);
+        index += 1;
+        mode = LEXICAL_MODE.code;
+        continue;
+      }
+      maskCharacter(masked, index);
+      continue;
+    }
+
+    if (mode === LEXICAL_MODE.string) {
+      if (character === '\\') {
+        maskCharacter(masked, index);
+        if (source[index + 1] !== undefined) {
+          maskCharacter(masked, index + 1);
+          index += 1;
+        }
+        continue;
+      }
+      const closesString = source.startsWith(delimiter, index);
+      if (closesString) {
+        for (let offset = 0; offset < delimiter.length; offset += 1) {
+          maskCharacter(masked, index + offset);
+        }
+        index += delimiter.length - 1;
+        delimiter = '';
+        mode = LEXICAL_MODE.code;
+        continue;
+      }
+      if (delimiter.length === 1 && character === '\n') {
+        mode = LEXICAL_MODE.code;
+        continue;
+      }
+      maskCharacter(masked, index);
+      continue;
+    }
+
+    const startsLineComment = character === '/' && source[index + 1] === '/';
+    if (startsLineComment) {
+      maskCharacter(masked, index);
+      maskCharacter(masked, index + 1);
+      index += 1;
+      mode = LEXICAL_MODE.lineComment;
+      continue;
+    }
+
+    const startsBlockComment = character === '/' && source[index + 1] === '*';
+    if (startsBlockComment) {
+      maskCharacter(masked, index);
+      maskCharacter(masked, index + 1);
+      index += 1;
+      mode = LEXICAL_MODE.blockComment;
+      continue;
+    }
+
+    const startsHashComment =
+      character === '#' && supportsHashComments(language);
+    if (startsHashComment) {
+      maskCharacter(masked, index);
+      mode = LEXICAL_MODE.lineComment;
+      continue;
+    }
+
+    const startsString =
+      character === "'" || character === '"' || character === '`';
+    if (startsString) {
+      delimiter = stringDelimiter(source, index, language, character);
+      for (let offset = 0; offset < delimiter.length; offset += 1) {
+        maskCharacter(masked, index + offset);
+      }
+      index += delimiter.length - 1;
+      mode = LEXICAL_MODE.string;
+    }
+  }
+
+  return masked.join('');
+}
+
+function stringDelimiter(
+  source: string,
+  index: number,
+  language: LanguageId,
+  quote: string,
+): string {
+  const tripleQuote = `${quote}${quote}${quote}`;
+  const isPythonTripleQuote =
+    language === LANGUAGE.python && source.startsWith(tripleQuote, index);
+  if (isPythonTripleQuote) {
+    return tripleQuote;
+  }
+  return quote;
+}
+
+function supportsHashComments(language: LanguageId): boolean {
+  return language === LANGUAGE.python || language === LANGUAGE.php;
+}
+
+function maskCharacter(masked: string[], index: number): void {
+  const character = masked[index];
+  const shouldMask =
+    character !== undefined && character !== '\n' && character !== '\r';
+  if (shouldMask) {
+    masked[index] = ' ';
+  }
+}

package/extensions/rules/model.ts

@@ -17,36 +17,187 @@ export function addedLines(
   next: string,
 ): AddedLine[] {
   const nextLines = next.split('\n');
-  const added: AddedLine[] = [];
-  const remaining = new Map<string, number>();
-
-  if (previous !== undefined) {
-    for (const text of previous.split('\n')) {
-      const key = text.trim();
-      if (key.length === 0) {
-        continue;
-      }
-      remaining.set(key, (remaining.get(key) ?? 0) + 1);
-    }
+  if (previous === undefined) {
+    return nonBlankLines(nextLines);
   }
 
-  for (let index = 0; index < nextLines.length; index += 1) {
+  const previousLines = previous.split('\n');
+  const insertedIndices = insertedLineIndices(previousLines, nextLines);
+  const availableAdditions = additionCounts(previousLines, nextLines);
+  const added: AddedLine[] = [];
+  const orderedIndices = [...insertedIndices].sort(
+    (left, right) => left - right,
+  );
+
+  for (const index of orderedIndices) {
     const text = nextLines[index] ?? '';
     const key = text.trim();
     if (key.length === 0) {
       continue;
     }
-    const count = remaining.get(key) ?? 0;
-    if (count > 0) {
-      remaining.set(key, count - 1);
+    const count = availableAdditions.get(key) ?? 0;
+    if (count === 0) {
       continue;
     }
+    availableAdditions.set(key, count - 1);
     added.push({ line: index + 1, text });
   }
 
   return added;
 }
 
+function nonBlankLines(lines: readonly string[]): AddedLine[] {
+  const added: AddedLine[] = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const text = lines[index] ?? '';
+    const trimmedText = text.trim();
+    if (trimmedText.length === 0) {
+      continue;
+    }
+    added.push({ line: index + 1, text });
+  }
+  return added;
+}
+
+function insertedLineIndices(
+  previousLines: readonly string[],
+  nextLines: readonly string[],
+): number[] {
+  const previousKeys = previousLines.map((line) => line.trim());
+  const nextKeys = nextLines.map((line) => line.trim());
+  const trace: Map<number, number>[] = [];
+  const frontier = new Map<number, number>([[1, 0]]);
+  const maximumDistance = previousLines.length + nextLines.length;
+
+  for (let distance = 0; distance <= maximumDistance; distance += 1) {
+    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+      const down = frontier.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY;
+      const right =
+        (frontier.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY) + 1;
+      let previousIndex: number;
+      const shouldMoveDown =
+        diagonal === -distance || (diagonal !== distance && down > right);
+      if (shouldMoveDown) {
+        previousIndex = down;
+      } else {
+        previousIndex = right;
+      }
+      const hasFiniteIndex = Number.isFinite(previousIndex);
+      if (!hasFiniteIndex) {
+        previousIndex = 0;
+      }
+
+      let nextIndex = previousIndex - diagonal;
+      while (
+        previousIndex < previousKeys.length &&
+        nextIndex < nextKeys.length &&
+        previousKeys[previousIndex] === nextKeys[nextIndex]
+      ) {
+        previousIndex += 1;
+        nextIndex += 1;
+      }
+      frontier.set(diagonal, previousIndex);
+
+      if (
+        previousIndex >= previousKeys.length &&
+        nextIndex >= nextKeys.length
+      ) {
+        trace.push(new Map(frontier));
+        return backtrackInsertedIndices(
+          trace,
+          distance,
+          previousKeys,
+          nextKeys,
+        );
+      }
+    }
+    trace.push(new Map(frontier));
+  }
+
+  throw new Error('Failed to compute the line diff.');
+}
+
+function backtrackInsertedIndices(
+  trace: readonly Map<number, number>[],
+  distance: number,
+  previousKeys: readonly string[],
+  nextKeys: readonly string[],
+): number[] {
+  let previousIndex = previousKeys.length;
+  let nextIndex = nextKeys.length;
+  const insertedIndices: number[] = [];
+
+  for (
+    let currentDistance = distance;
+    currentDistance > 0;
+    currentDistance -= 1
+  ) {
+    const previousFrontier = trace[currentDistance - 1];
+    if (previousFrontier === undefined) {
+      throw new Error('Line diff trace is incomplete.');
+    }
+
+    const diagonal = previousIndex - nextIndex;
+    const down = previousFrontier.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY;
+    const right =
+      (previousFrontier.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY) + 1;
+    const shouldMoveDown =
+      diagonal === -currentDistance ||
+      (diagonal !== currentDistance && down > right);
+    const previousDiagonal = shouldMoveDown ? diagonal + 1 : diagonal - 1;
+    const previousOldIndex = previousFrontier.get(previousDiagonal);
+    if (previousOldIndex === undefined) {
+      throw new Error('Line diff trace has an invalid diagonal.');
+    }
+    const previousNextIndex = previousOldIndex - previousDiagonal;
+
+    while (
+      previousIndex > previousOldIndex &&
+      nextIndex > previousNextIndex &&
+      previousKeys[previousIndex - 1] === nextKeys[nextIndex - 1]
+    ) {
+      previousIndex -= 1;
+      nextIndex -= 1;
+    }
+
+    if (previousIndex === previousOldIndex) {
+      nextIndex -= 1;
+      insertedIndices.push(nextIndex);
+    } else {
+      previousIndex -= 1;
+    }
+  }
+
+  return insertedIndices;
+}
+
+function additionCounts(
+  previousLines: readonly string[],
+  nextLines: readonly string[],
+): Map<string, number> {
+  const previousCounts = countLineKeys(previousLines);
+  const nextCounts = countLineKeys(nextLines);
+  const additions = new Map<string, number>();
+
+  for (const [key, nextCount] of nextCounts) {
+    const previousCount = previousCounts.get(key) ?? 0;
+    additions.set(key, Math.max(nextCount - previousCount, 0));
+  }
+  return additions;
+}
+
+function countLineKeys(lines: readonly string[]): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const line of lines) {
+    const key = line.trim();
+    if (key.length === 0) {
+      continue;
+    }
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+
 export function formatBlockReason(
   path: string,
   violations: readonly RuleViolation[],

package/extensions/todo/execute.ts

@@ -5,7 +5,7 @@ import {
   TODO_ACTION,
   type TodoAction,
   type TodoItem,
-  type TodoParams,
+  type TodoToolParameters,
   UI_UNAVAILABLE,
 } from './model.ts';
 
@@ -21,7 +21,7 @@ export interface TodoToolResult {
 }
 
 export function executeTodo(
-  params: TodoParams,
+  params: TodoToolParameters,
   ctx: Pick<ExtensionContext, 'mode'>,
   currentItems: readonly TodoItem[],
 ): TodoToolResult {