nolo-cli 0.13.0 → 0.14.0-alpha.1

package/{chunk-MG6BVV3T.js → chunk-BRODTPXY.js}

@@ -4,10 +4,10 @@ import {
   providerHttpFailure,
   readSseFrames,
   throwIfChatCompletionStreamFailed
-} from "./chunk-5S4SWV5G.js";
+} from "./chunk-PB2DHBEQ.js";
 import {
   parseToolArgumentsJson
-} from "./chunk-TA7VKOHU.js";
+} from "./chunk-7H3O7ZA2.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -17,12 +17,12 @@ import {
 import {
   requiresBareImageUrl,
   toBareImageUrlMessages
-} from "./chunk-LUKQQJFL.js";
+} from "./chunk-UW3WOIWJ.js";
 import {
   buildProviderAuthHeaders,
   buildProviderExecutionPlan,
   toOpenAiCompatibleMessages
-} from "./chunk-TYPHUVK5.js";
+} from "./chunk-KTFJUPDW.js";
 import {
   canonicalizeToolName,
   createGlob,
@@ -46,15 +46,15 @@ import {
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";
@@ -1225,30 +1225,18 @@ function buildReadWorkspaceDescription(variant) {
     return "Read a UTF-8 text file inside the workspace.";
   }
   if (variant === "workflow") {
-    return "Read a UTF-8 text file inside the workspace after listFiles, globFiles, or searchFiles has narrowed the target. Use line ranges from searchFiles matches and tailLines for logs or generated output. Read the whole file only when the task truly needs all content or exact edit context.";
+    return 'Read a UTF-8 text file inside the workspace after listFiles, globFiles, or searchFiles has narrowed the target. Use lines with a range from searchFiles matches, or lines: "-50" for logs and generated output. Read the whole file only when the task truly needs all content or exact edit context.';
   }
   if (variant === "antiShell") {
     return "Read a UTF-8 text file inside the workspace. Do not use execShell with cat/sed/head/tail for normal text reads when readFile can return the needed file or line range. Use searchFiles first for content search, then readFile only the relevant lines when possible.";
   }
-  return "Read a UTF-8 text file inside the workspace. Read before editing when you need exact text for editFile. For discovery or classification tasks, avoid batch-reading every candidate; report candidate paths first, or read only one to three representative files with maxLines or focused line ranges. Use line ranges for large code, docs, data, configs, and logs after searchFiles returns line numbers. Read the whole file only when the task truly needs all content or exact edit context.";
+  return "Read a UTF-8 text file inside the workspace. Read before editing when you need exact text for editFile. For discovery or classification tasks, avoid batch-reading every candidate; report candidate paths first, or read only one to three representative files with a small lines count. Use lines ranges for large code, docs, data, configs, and logs after searchFiles returns line numbers. Read the whole file only when the task truly needs all content or exact edit context.";
 }
 function buildReadWorkspaceParameters(variant) {
   const path = buildWorkspacePathProperty();
-  const startLine = {
-    type: "integer",
-    description: "1-based first line to return. Use with endLine or maxLines after searchFiles gives a line number."
-  };
-  const endLine = {
-    type: "integer",
-    description: "1-based last line to return, inclusive."
-  };
-  const maxLines = {
-    type: "integer",
-    description: "Maximum number of lines to return starting at startLine, or from the start of the file when startLine is omitted. Use for lightweight previews of candidate configs, docs, data, and logs instead of reading many whole files. When the user gives a read/preview budget, each readFile preview consumes one budget slot."
-  };
-  const tailLines = {
-    type: "integer",
-    description: "Return only the last N lines, useful for logs and generated text."
+  const lines = {
+    type: "string",
+    description: 'Which lines to return: "40-120" for a range (1-based, inclusive), "120-" from a line to the end, "-50" for the last N lines (logs, generated output), "50" for the first N. Omit to read the whole file. Use a range after searchFiles gives a line number, and a small count to preview candidates instead of reading many whole files. When the user gives a read/preview budget, each readFile preview consumes one budget slot.'
   };
   if (variant === "minimal") {
     return {
@@ -1257,27 +1245,9 @@ function buildReadWorkspaceParameters(variant) {
       required: ["path"]
     };
   }
-  if (variant === "rich") {
-    return {
-      type: "object",
-      properties: {
-        path,
-        startLine,
-        endLine,
-        maxLines,
-        tailLines
-      },
-      required: ["path"]
-    };
-  }
   return {
     type: "object",
-    properties: {
-      path,
-      startLine,
-      endLine,
-      maxLines
-    },
+    properties: { path, lines },
     required: ["path"]
   };
 }
@@ -2014,31 +1984,120 @@ function readExpectedReplacementCount(args) {
   }
   return value;
 }
-function readPositiveIntegerArg(args) {
-  if (args.value === void 0) return void 0;
+var READ_FILE_SLICE_FALLBACK_LINES = 200;
+var LEGACY_SLICE_ARG_NAMES = ["startLine", "endLine", "maxLines", "tailLines"];
+function isAbsentArg(value) {
+  return value === void 0 || value === null;
+}
+function describeRejectedArgValue(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) return "an array";
+  return `a value of type ${typeof value}`;
+}
+function readIntegerArg(args) {
+  if (isAbsentArg(args.value)) return {};
+  const min = args.min ?? 1;
   const value = Number(args.value);
-  if (!Number.isInteger(value) || value < 1) {
-    throw new Error(`${args.name} must be a positive integer.`);
+  if (!Number.isInteger(value) || value < min) {
+    const expected = min === 0 ? "a non-negative integer" : "a positive integer";
+    return {
+      warning: `Ignored ${args.name}: expected ${expected}, received ${describeRejectedArgValue(args.value)}.`
+    };
   }
-  return args.max ? Math.min(value, args.max) : value;
+  return { value: args.max ? Math.min(value, args.max) : value };
 }
-function readFileSliceArgs(args) {
-  const startLine = readPositiveIntegerArg({ value: args.startLine, name: "startLine" });
-  const endLine = readPositiveIntegerArg({ value: args.endLine, name: "endLine" });
-  const maxLines = readPositiveIntegerArg({ value: args.maxLines, name: "maxLines", max: 2e3 });
-  const tailLines = readPositiveIntegerArg({ value: args.tailLines, name: "tailLines", max: 2e3 });
-  if (tailLines !== void 0 && (startLine !== void 0 || endLine !== void 0)) {
-    throw new Error("tailLines cannot be combined with startLine or endLine.");
+function collectIntegerArg(args) {
+  const { value, warning } = readIntegerArg(args);
+  if (warning) {
+    args.warnings.push(
+      args.fallback === void 0 ? warning : `${warning} Using ${args.fallback} instead.`
+    );
   }
-  if (endLine !== void 0 && startLine !== void 0 && endLine < startLine) {
-    throw new Error("endLine must be greater than or equal to startLine.");
+  return value ?? args.fallback;
+}
+var LINES_ARG_SYNTAX = '"40-120", "120-", "-50", or "50"';
+var LINES_RANGE_FORMAT = /^(\d+)?\s*-\s*(\d+)?$/;
+function parseLinesArg(value) {
+  const text = typeof value === "string" ? value.trim() : "";
+  if (!text) {
+    return {
+      warning: `Ignored lines: expected ${LINES_ARG_SYNTAX}, received ${describeRejectedArgValue(value)}.`
+    };
   }
-  return {
-    startLine,
-    endLine,
-    maxLines,
-    tailLines
+  const reject = {
+    warning: `Ignored lines: expected ${LINES_ARG_SYNTAX}, received ${JSON.stringify(text)}.`
+  };
+  if (/^\d+$/.test(text)) {
+    const count = Number(text);
+    return count > 0 ? { slice: { maxLines: Math.min(count, 2e3) } } : reject;
+  }
+  const range = LINES_RANGE_FORMAT.exec(text);
+  if (!range) return reject;
+  const [, rawStart, rawEnd] = range;
+  if (rawStart === void 0 && rawEnd === void 0) return reject;
+  if (rawStart === void 0) {
+    const tail = Number(rawEnd);
+    return tail > 0 ? { slice: { tailLines: Math.min(tail, 2e3) } } : reject;
+  }
+  const startLine = Number(rawStart);
+  if (startLine < 1) return reject;
+  if (rawEnd === void 0) return { slice: { startLine } };
+  const endLine = Number(rawEnd);
+  if (endLine < startLine) {
+    return {
+      warning: `Ignored lines ${JSON.stringify(text)}: the end line must be greater than or equal to the start line.`
+    };
+  }
+  return { slice: { startLine, endLine } };
+}
+function readFileSliceArgs(args) {
+  const warnings = [];
+  const legacyUsed = LEGACY_SLICE_ARG_NAMES.filter((name) => !isAbsentArg(args[name]));
+  const withFallback = (slice) => {
+    warnings.push(
+      `No usable line range remained; returned the first ${READ_FILE_SLICE_FALLBACK_LINES} lines instead of the whole file.`
+    );
+    return { ...slice, maxLines: READ_FILE_SLICE_FALLBACK_LINES, warnings };
   };
+  if (!isAbsentArg(args.lines)) {
+    if (legacyUsed.length > 0) {
+      warnings.push(`Ignored ${legacyUsed.join(", ")}: superseded by lines.`);
+    }
+    const { slice, warning } = parseLinesArg(args.lines);
+    if (warning) warnings.push(warning);
+    return slice ? { ...slice, warnings } : withFallback({});
+  }
+  if (legacyUsed.length === 0) return { warnings };
+  warnings.push(
+    `${legacyUsed.join(", ")} ${legacyUsed.length > 1 ? "are" : "is"} deprecated; use lines instead (${LINES_ARG_SYNTAX}).`
+  );
+  const take = (name, max) => collectIntegerArg({ value: args[name], name, max, warnings });
+  const resolved = {
+    startLine: take("startLine"),
+    endLine: take("endLine"),
+    maxLines: take("maxLines", 2e3),
+    tailLines: take("tailLines", 2e3)
+  };
+  if (resolved.endLine !== void 0 && resolved.startLine !== void 0 && resolved.endLine < resolved.startLine) {
+    warnings.push(
+      `Ignored endLine (${resolved.endLine}): endLine must be greater than or equal to startLine (${resolved.startLine}).`
+    );
+    resolved.endLine = void 0;
+  }
+  if (resolved.tailLines !== void 0 && (resolved.startLine !== void 0 || resolved.endLine !== void 0)) {
+    warnings.push(
+      `Ignored tailLines (${resolved.tailLines}): tailLines cannot be combined with startLine or endLine.`
+    );
+    resolved.tailLines = void 0;
+  }
+  const nothingUsable = LEGACY_SLICE_ARG_NAMES.every((name) => resolved[name] === void 0);
+  return nothingUsable ? withFallback(resolved) : { ...resolved, warnings };
+}
+function buildReadFileSliceHint(totalLines) {
+  return `File has ${totalLines} lines. Use lines: ${LINES_ARG_SYNTAX}, or omit it for the whole file.`;
 }
 function splitTextLines(content) {
   const lines = content.split(/\r?\n/);
@@ -2128,36 +2187,42 @@ function requireWorkspaceGlobPattern(args) {
   if (!pattern) throw new Error("globFiles requires a non-empty pattern.");
   return pattern;
 }
-function readWorkspaceMaxResults(args, defaultValue) {
-  if (args.maxResults === void 0) return defaultValue;
-  const value = Number(args.maxResults);
-  if (!Number.isInteger(value) || value < 1) {
-    throw new Error("maxResults must be a positive integer.");
-  }
-  return Math.min(value, 500);
-}
-function readWorkspaceMaxDepth(args) {
-  if (args.maxDepth === void 0) return 1;
-  const value = Number(args.maxDepth);
-  if (!Number.isInteger(value) || value < 1) {
-    throw new Error("maxDepth must be a positive integer.");
-  }
-  return Math.min(value, 10);
+function readWorkspaceMaxResults(args, warnings, defaultValue) {
+  return collectIntegerArg({
+    value: args.maxResults,
+    name: "maxResults",
+    max: 500,
+    fallback: defaultValue,
+    warnings
+  });
 }
-function readWorkspaceEntryType(args) {
-  if (args.entryType === void 0) return "all";
-  if (args.entryType === "all" || args.entryType === "files" || args.entryType === "directories") {
-    return args.entryType;
-  }
-  throw new Error("entryType must be one of all, files, or directories.");
+function readWorkspaceMaxDepth(args, warnings) {
+  return collectIntegerArg({
+    value: args.maxDepth,
+    name: "maxDepth",
+    max: 10,
+    fallback: 1,
+    warnings
+  });
 }
-function readWorkspaceContextLines(args) {
-  if (args.contextLines === void 0) return void 0;
-  const value = Number(args.contextLines);
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error("contextLines must be a non-negative integer.");
-  }
-  return Math.min(value, 20);
+var WORKSPACE_ENTRY_TYPES = ["all", "files", "directories"];
+function readWorkspaceEntryType(args, warnings) {
+  if (isAbsentArg(args.entryType)) return "all";
+  const entryType = WORKSPACE_ENTRY_TYPES.find((value) => value === args.entryType);
+  if (entryType) return entryType;
+  warnings.push(
+    `Ignored entryType: expected one of ${WORKSPACE_ENTRY_TYPES.join(", ")}, received ${describeRejectedArgValue(args.entryType)}. Using all instead.`
+  );
+  return "all";
+}
+function readWorkspaceContextLines(args, warnings) {
+  return collectIntegerArg({
+    value: args.contextLines,
+    name: "contextLines",
+    min: 0,
+    max: 20,
+    warnings
+  });
 }
 function readWorkspaceExcludeGlobs(args) {
   if (args.exclude === void 0) return [];
@@ -2632,7 +2697,7 @@ async function resolveLocalWorkspaceToolPath(args) {
 async function readFileTool(args) {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
   const requestedPath = requireWorkspaceToolPath(parsed);
-  const sliceArgs = readFileSliceArgs(parsed);
+  const { warnings, ...sliceArgs } = readFileSliceArgs(parsed);
   const absolutePath = await resolveLocalWorkspaceToolPath({
     workspaceRoot: args.workspaceRoot,
     requestedPath,
@@ -2659,6 +2724,7 @@ async function readFileTool(args) {
       truncated: sliced.truncated,
       ...sliceArgs.maxLines ? { maxLines: sliceArgs.maxLines } : {},
       ...sliceArgs.tailLines ? { tailLines: sliceArgs.tailLines } : {},
+      ...warnings.length ? { warnings: [...warnings, buildReadFileSliceHint(sliced.totalLines)] } : {},
       ...activity ? { activity } : {}
     }
   };
@@ -2789,10 +2855,11 @@ async function listWorkspaceEntries(args) {
 }
 async function listFilesTool(args) {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const warnings = [];
   const requestedPath = readWorkspacePathAlias(parsed) ?? ".";
-  const maxDepth = readWorkspaceMaxDepth(parsed);
-  const maxResults = readWorkspaceMaxResults(parsed);
-  const entryType = readWorkspaceEntryType(parsed);
+  const maxDepth = readWorkspaceMaxDepth(parsed, warnings);
+  const maxResults = readWorkspaceMaxResults(parsed, warnings);
+  const entryType = readWorkspaceEntryType(parsed, warnings);
   const dirPath = await resolveLocalWorkspaceToolPath({
     workspaceRoot: args.workspaceRoot,
     requestedPath,
@@ -2816,16 +2883,18 @@ async function listFilesTool(args) {
       limitedByMaxResults: listed.truncated,
       limitedByMaxDepth: listed.limitedByMaxDepth,
       visitedEntries: listed.visitedEntries,
-      ...maxResults ? { maxResults } : {}
+      ...maxResults ? { maxResults } : {},
+      ...warnings.length ? { warnings } : {}
     }
   };
 }
 async function searchFilesTool(args) {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const warnings = [];
   const query = requireWorkspaceSearchQuery(parsed);
   const exclude = readWorkspaceExcludeGlobs(parsed);
-  const maxResults = readWorkspaceMaxResults(parsed, DEFAULT_SEARCH_MAX_RESULTS);
-  const contextLines = readWorkspaceContextLines(parsed);
+  const maxResults = readWorkspaceMaxResults(parsed, warnings, DEFAULT_SEARCH_MAX_RESULTS);
+  const contextLines = readWorkspaceContextLines(parsed, warnings);
   const literal = parsed.literal === true;
   const caseSensitive = parsed.caseSensitive === false ? false : true;
   const requestedPath = readWorkspacePathAlias(parsed) ?? ".";
@@ -2983,6 +3052,7 @@ async function searchFilesTool(args) {
       ...maxResults ? { maxResults } : {},
       exitCode: result.exitCode,
       searchEngine,
+      ...warnings.length ? { warnings } : {},
       ...extractActivity(parsed) ? { activity: extractActivity(parsed) } : {}
     }
   };
@@ -3099,9 +3169,10 @@ async function scanWorkspaceTextMatches(args) {
 }
 async function globFilesTool(args) {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const warnings = [];
   const pattern = requireWorkspaceGlobPattern(parsed);
   const exclude = readWorkspaceExcludeGlobs(parsed);
-  const maxResults = readWorkspaceMaxResults(parsed);
+  const maxResults = readWorkspaceMaxResults(parsed, warnings);
   const requestedPath = readWorkspacePathAlias(parsed) ?? ".";
   const includeIgnored = parsed.includeIgnored === true;
   const searchPath = await resolveLocalWorkspaceToolPath({
@@ -3205,6 +3276,7 @@ async function globFilesTool(args) {
       ...maxResults ? { maxResults } : {},
       exitCode,
       searchEngine,
+      ...warnings.length ? { warnings } : {},
       ...activity ? { activity } : {}
     }
   };

package/{chunk-C3BFP57W.js → chunk-CANREHJB.js}

@@ -1,7 +1,7 @@
 import {
   i18n_default,
   toolRegistry
-} from "./chunk-MZHSAPZP.js";
+} from "./chunk-HXPBV44X.js";
 import {
   canonicalizeToolNames
 } from "./chunk-B4KT7RN2.js";

package/{chunk-DPFWKRHG.js → chunk-CFX7LP6W.js}

@@ -1,7 +1,7 @@
 import {
   selectCurrentServer,
   selectRemoteServers
-} from "./chunk-JU7J7EAV.js";
+} from "./chunk-EC2EU2F4.js";
 import {
   createUserKey,
   extractAgentInfo,
@@ -16,7 +16,7 @@ import {
   noloWriteRequest,
   selectIdentityUser,
   selectIdentityUserId
-} from "./chunk-TSUJOM6N.js";
+} from "./chunk-DVRHHFEA.js";
 import {
   normalizeTimeFields
 } from "./chunk-OOSFSFMA.js";

package/{chunk-QJSTNKJY.js → chunk-DSCG2DY5.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_AGENT_BASE_POLICY,
   DEFAULT_USER_PREFERENCE_PROFILE
-} from "./chunk-JU7J7EAV.js";
+} from "./chunk-EC2EU2F4.js";
 
 // packages/ai/policy/runtimePolicy.ts
 var clampLevel = (value, fallback) => {

package/{chunk-JU7J7EAV.js → chunk-EC2EU2F4.js}

@@ -10,7 +10,7 @@ import {
   toTimestampMs,
   upsert,
   write
-} from "./chunk-VKG4HXYV.js";
+} from "./chunk-V6PGKRZC.js";
 import {
   createUserKey,
   createUserPreferenceKey,
@@ -21,7 +21,7 @@ import {
 } from "./chunk-QSJ3HFEF.js";
 import {
   BUILTIN_NOLO_AGENT_KEY
-} from "./chunk-XHQWJUW4.js";
+} from "./chunk-NJVPXLRY.js";
 import {
   asyncThunkCreator,
   buildCreateSlice,
@@ -29,7 +29,7 @@ import {
   createAsyncThunk,
   createSelector,
   selectIdentityUserId
-} from "./chunk-TSUJOM6N.js";
+} from "./chunk-DVRHHFEA.js";
 import {
   getAllServers,
   getIsDesktopApp,

package/{chunk-VBSWHE5W.js → chunk-FLY6L3KA.js}

@@ -1,7 +1,7 @@
 import {
   buildAgentRuntimeAgentLookupKeys,
   shouldFetchAgentRuntimeRecordRemotely
-} from "./chunk-MG6BVV3T.js";
+} from "./chunk-BRODTPXY.js";
 
 // packages/cli/client/localAgentRecords.ts
 var buildLocalAgentLookupKeys = buildAgentRuntimeAgentLookupKeys;