@rmrdeveloper/sideroom-pi 8.0.2 → 8.1.1

package/extensions/rules/model.ts

@@ -0,0 +1,220 @@
+import type { RuleId, RuleSeverity } from './catalog.ts';
+
+export interface AddedLine {
+  readonly line: number;
+  readonly text: string;
+}
+
+export interface RuleViolation {
+  readonly ruleId: RuleId;
+  readonly severity: RuleSeverity;
+  readonly message: string;
+  readonly line: number;
+}
+
+export function addedLines(
+  previous: string | undefined,
+  next: string,
+): AddedLine[] {
+  const nextLines = next.split('\n');
+  if (previous === undefined) {
+    return nonBlankLines(nextLines);
+  }
+
+  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 = 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[],
+): string {
+  return [
+    `Blocked ${path}: sideroom rules violated.`,
+    ...violations.map((item) => `- ${item.message}`),
+    'Fix the flagged lines and retry the mutation.',
+  ].join('\n');
+}
+
+export function formatWarnings(
+  path: string,
+  violations: readonly RuleViolation[],
+): string {
+  return [
+    `Sideroom rules flagged ${path}:`,
+    ...violations.map((item) => `- ${item.message}`),
+  ].join('\n');
+}

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 {

package/extensions/todo/index.ts

@@ -2,7 +2,11 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Text } from '@earendil-works/pi-tui';
 import { executeTodo, type TodoToolDetails } from './execute.ts';
 import { registerGuardEvents } from './guards.ts';
-import { prepareTodoArguments, TOOL_NAME, TodoParamsSchema } from './model.ts';
+import {
+  prepareTodoArguments,
+  TOOL_NAME,
+  TodoToolParametersSchema,
+} from './model.ts';
 import {
   type BoardLifecycle,
   commitBoard,
@@ -59,7 +63,7 @@ function registerTodoTool(
     description: TODO_DESCRIPTION,
     promptSnippet: TODO_PROMPT_SNIPPET,
     promptGuidelines: TODO_PROMPT_GUIDELINES,
-    parameters: TodoParamsSchema,
+    parameters: TodoToolParametersSchema,
     prepareArguments: prepareTodoArguments,
     executionMode: 'sequential',
     execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {

package/extensions/todo/model.ts

@@ -27,6 +27,11 @@ const TodoStatusSchema = Type.Union([
   Type.Literal(TODO_STATUS.cancelled),
 ]);
 
+const TodoActionSchema = Type.Union([
+  Type.Literal(TODO_ACTION.propose),
+  Type.Literal(TODO_ACTION.update),
+]);
+
 const TodoItemSchema = Type.Object({
   id: Type.String({ description: 'Stable identifier for this item' }),
   content: Type.String({ description: 'Short description of the work' }),
@@ -41,28 +46,53 @@ const TodoPatchSchema = Type.Object({
   ),
 });
 
+const TodoItemsField = Type.Array(TodoItemSchema, {
+  maxItems: MAX_TODO_ITEMS,
+  description: 'Replacement board for propose, with at most 20 items',
+});
+
+const TodoPatchesField = Type.Array(TodoPatchSchema, {
+  minItems: 1,
+  description: 'Patches to apply for update',
+});
+
 const ProposeParamsSchema = Type.Object({
   action: Type.Literal(TODO_ACTION.propose),
-  items: Type.Array(TodoItemSchema, {
-    maxItems: MAX_TODO_ITEMS,
-    description: 'Replacement board, with at most 20 items',
-  }),
+  items: TodoItemsField,
 });
 
 const UpdateParamsSchema = Type.Object({
   action: Type.Literal(TODO_ACTION.update),
-  patches: Type.Array(TodoPatchSchema, {
-    minItems: 1,
-    description: 'Patches to apply together',
-  }),
+  patches: TodoPatchesField,
 });
 
+/**
+ * Strict validator and types for sideroom_todo arguments. Kept as a
+ * discriminated union so invalid action/field combinations are rejected
+ * exactly. This schema is not registered with Pi; see
+ * TodoToolParametersSchema.
+ */
 export const TodoParamsSchema = Type.Union([
   ProposeParamsSchema,
   UpdateParamsSchema,
 ]);
 
+/**
+ * Tool-facing schema registered with Pi. It must stay a top-level object:
+ * Claude Code silently drops every tool of an MCP server when one tool's
+ * inputSchema has a non-object top level (anyOf/oneOf/allOf), which is exactly
+ * what TodoParamsSchema emits. The discriminated union is still enforced at
+ * runtime by parseTodoParams. See docs/extensions/todo.md ("Tool schema
+ * compatibility") for the bug references and the condition to revert.
+ */
+export const TodoToolParametersSchema = Type.Object({
+  action: TodoActionSchema,
+  items: Type.Optional(TodoItemsField),
+  patches: Type.Optional(TodoPatchesField),
+});
+
 export type TodoParams = Static<typeof TodoParamsSchema>;
+export type TodoToolParameters = Static<typeof TodoToolParametersSchema>;
 export type TodoAction = (typeof TODO_ACTION)[keyof typeof TODO_ACTION];
 export type TodoStatus = (typeof TODO_STATUS)[keyof typeof TODO_STATUS];
 
@@ -127,8 +157,8 @@ type JsonWireValue =
   | readonly JsonWireValue[]
   | JsonWireObject;
 
-export function prepareTodoArguments(args: unknown): TodoParams {
-  return decodeTodoWireArgs(args) as TodoParams;
+export function prepareTodoArguments(args: unknown): TodoToolParameters {
+  return decodeTodoWireArgs(args) as TodoToolParameters;
 }
 
 function decodeTodoWireArgs(args: unknown): JsonWireValue {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rmrdeveloper/sideroom-pi",
-  "version": "8.0.2",
-  "description": "A global Pi package with a questionnaire, work board, edited-file view, and coding guidelines for parent agents.",
+  "version": "8.1.1",
+  "description": "A global Pi package with a questionnaire, work board, edited-file view, coding guidelines, rule enforcement, and a finish gate for parent agents.",
   "type": "module",
   "files": [
     "extensions",

package/skills/sideroom-guidelines/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: sideroom-guidelines
-description: "Apply Sideroom's mandatory coding workflow before implementing, refactoring, or fixing Java, Laravel/PHP, TypeScript/TSX, Python, Go, or Rust code. Load this skill and the exact language guide before mutation. Do not use for unrelated prose or domain-only discussions."
+description: "Apply Sideroom's mandatory coding workflow before implementing, refactoring, or fixing Java, Laravel/PHP, JavaScript/JSX, TypeScript/TSX, Python, Go, or Rust code. Load this skill and the exact language guide before mutation. Do not use for unrelated prose or domain-only discussions."
 license: MIT
 metadata:
   author: RMRdeveloper
@@ -26,6 +26,7 @@ Load this whole skill with `read`, without `offset` or `limit`, before the first
 | Path | Read |
 | ------ | ------ |
 | `.java` | `references/languages/java.md` |
+| `.js` `.jsx` `.mjs` `.cjs` | `references/languages/javascript.md` |
 | `.php` | `references/languages/php-laravel.md` |
 | `.ts` `.tsx` | `references/languages/typescript.md` |
 | `.py` | `references/languages/python.md` |
@@ -74,6 +75,7 @@ Changed code follows every applicable rule in the loaded complete guide. The fin
 ## References
 
 - `references/languages/java.md`
+- `references/languages/javascript.md`
 - `references/languages/php-laravel.md`
 - `references/languages/typescript.md`
 - `references/languages/python.md`