codemode-lsp 0.1.1 → 0.1.2

package/dist/index.js

@@ -46102,6 +46102,25 @@ function buildTracedLsp(api2, trace, makeSandboxError, wrapAsync, opNames) {
   return traced;
 }
 var hostPath = { join: join2, basename, dirname: dirname4, extname };
+var UNCAPTURED_STATEMENT_NAMES = {
+  IfStatement: "an if statement",
+  ForStatement: "a for loop",
+  ForOfStatement: "a for...of loop",
+  ForInStatement: "a for...in loop",
+  WhileStatement: "a while loop",
+  DoWhileStatement: "a do...while loop",
+  TryStatement: "a try/catch block",
+  SwitchStatement: "a switch statement",
+  BlockStatement: "a block",
+  VariableDeclaration: "a variable declaration",
+  FunctionDeclaration: "a function declaration",
+  ClassDeclaration: "a class declaration"
+};
+function describeUncapturedStatement(type) {
+  if (type === "ReturnStatement")
+    return;
+  return UNCAPTURED_STATEMENT_NAMES[type] ?? `a ${type}`;
+}
 function isExpressionStatement(node) {
   return node.type === "ExpressionStatement";
 }
@@ -46137,8 +46156,14 @@ function normalizeCode(code) {
     return { source: `${head}
 return (${expr});` };
   }
-  return { source: `${trimmed}
-return undefined;` };
+  return {
+    source: `${trimmed}
+return undefined;`,
+    ...last ? (() => {
+      const described = describeUncapturedStatement(last.type);
+      return described ? { uncapturedLastStatement: described } : {};
+    })() : {}
+  };
 }
 function capText(text, cap, marker) {
   if (text.length <= cap)
@@ -46249,7 +46274,7 @@ async function runSandbox(code, options) {
   };
   const opNames = options.readonly ? [...READ_OP_NAMES] : [...READ_OP_NAMES, ...WRITE_OP_NAMES];
   sandbox.lsp = buildTracedLsp(options.lsp, trace, makeSandboxError, wrapAsync, opNames);
-  const { source } = normalizeCode(code);
+  const { source, uncapturedLastStatement } = normalizeCode(code);
   const wrapped = `(async () => {
 ${source}
 })()`;
@@ -46290,7 +46315,7 @@ ${source}
   }
   let result;
   try {
-    result = serializeResult(value);
+    result = value === undefined && uncapturedLastStatement ? `undefined — note: the script's last statement is ${uncapturedLastStatement}, ` + "which produces no capturable value. Only a top-level trailing " + "expression becomes the result — end the script with a bare " + "expression (e.g. `({ count })`), or use a top-level `return`." : serializeResult(value);
   } catch (error51) {
     throw new SandboxError({
       error: error51 instanceof Error ? error51.message : String(error51),
@@ -46469,11 +46494,11 @@ ${LSP_WRITE_INTERFACES}`;
 
   // Write operations — buffered, applied atomically when the script succeeds.
 ${LSP_WRITE_OP_SIGNATURES}`;
-  return `${interfaces}
-
-declare const lsp: {
+  return `declare const lsp: {
 ${ops}
-};`;
+};
+
+${interfaces}`;
 }
 var TEMPLATE = `Execute JavaScript to perform semantic code operations via LSP (TypeScript).
 
@@ -46484,36 +46509,41 @@ instead of across many tool calls. The sandbox provides \`lsp\`,
 setTimeout). The tool returns { result, logs, changes }, where \`result\` is the
 script's last expression, JSON-serialized.
 
-## API
-
-{{types}}
-
-{{writeSemantics}}
-
-## Examples
-
-{{examples}}
-
 ## Rules
 
-- The last expression is the return value — end the script with the value you
-  want back, e.g. \`({ count })\`.
+- The last TOP-LEVEL expression is the return value — end the script with a
+  bare expression, e.g. \`({ count })\`. An expression inside a trailing
+  if/for/try block is NOT captured; use a top-level \`return\` from inside
+  blocks.
 - Every \`lsp.*\` call returns a Promise — always \`await\` it. An un-awaited
   call inside the result serializes as \`{}\`.
 - \`.filter()\`/\`.map()\` callbacks cannot be async — use \`for...of\` with \`await\`.
-- Globs match the whole workspace-relative path: \`listFiles("src/**")\` for a
-  directory (a bare directory name like \`"src"\` is treated as \`src/**\`),
-  \`listFiles()\` for every file. \`searchText\`'s second argument is a glob
-  string — there is no options object; filter results in your script.
+- \`searchText\`/\`listFiles\` cover the whole workspace (minus .gitignore);
+  scope with a glob, which matches the full workspace-relative path:
+  \`listFiles("src/**")\` for a directory (a bare name like \`"src"\` is treated
+  as \`src/**\`), \`listFiles()\` for every file. \`searchText\`'s second argument
+  is a glob string — there is no options object; filter results in your script.
 - Symbol paths are slash-separated (\`MyClass/myMethod\`); discover exact paths
   with \`getSymbols(file)\` rather than guessing. Symbol ops always take the
   pair \`(file, symbolPath)\` — a \`SymbolInfo.path\` belongs to the file you
-  called \`getSymbols\` on.
+  called \`getSymbols\` on, and round-trips into findReferences/goToDefinition/
+  the write ops.
 - \`searchText\` patterns are regexes — escape metacharacters for literal text:
   \`searchText("new NotFoundError\\\\(")\`.
 - File paths are relative to the workspace root; anything outside it is
   rejected.
-- Diagnostics cover files touched this session only, never the whole project.`;
+- Diagnostics cover files touched this session only, never the whole project.
+  \`Diagnostic.range\` is zero-based; every other line/column is 1-based.
+
+## API
+
+{{types}}
+
+{{writeSemantics}}
+
+## Examples
+
+{{examples}}`;
 var WRITE_SEMANTICS = `Write operations available: writes are buffered during the script and applied
 atomically (flushed to disk) only when the whole script succeeds; if it throws,
 every buffered write is rolled back and the codebase is unchanged. The tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemode-lsp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "MCP server exposing a single code-mode tool backed by LSP",
   "keywords": [
     "mcp",