nou-cli 0.5.3 → 0.5.6

package/dist/src/guide/index.js

@@ -0,0 +1,100 @@
+import path from "path";
+export const SHOW_STEPS = "show_steps";
+/** The tool the engine hands its steps back with. `onSteps` gets them; the engine is told they're shown. */
+export function showStepsTool(onSteps) {
+    return {
+        definition: {
+            name: SHOW_STEPS,
+            description: "Only when the user asked you to show them how ([Show me how] in their message): hand back the change as steps for them to type themselves, instead of editing. Each step adds whole lines of code before a line of a file, with why it's needed. Call it once, with every step in order.",
+            parameters: {
+                type: "object",
+                properties: {
+                    steps: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                file: { type: "string", description: "Project-relative path of the file to add to." },
+                                line: { type: "number", description: "1-based line the code goes in before (the line after the last one appends)." },
+                                code: { type: "string", description: "The lines to type, indented as they'll be in the file." },
+                                why: { type: "string", description: "One or two plain sentences: what this does and why it's needed." },
+                            },
+                            required: ["file", "line", "code", "why"],
+                        },
+                    },
+                },
+                required: ["steps"],
+            },
+        },
+        readOnly: true,
+        source: "nou",
+        run: (args) => {
+            const steps = tidySteps(args.steps);
+            if (!steps.length)
+                return "No usable steps: each needs a file, a line and the code to type. Call show_steps again.";
+            onSteps(steps);
+            return `Shown to the user as ${steps.length} step${steps.length > 1 ? "s" : ""} to type. Don't edit the files yourself; finish with a one-line summary.`;
+        },
+    };
+}
+/** Steps as the model gave them, kept when usable: a file, a line, code to type. */
+function tidySteps(raw) {
+    return (Array.isArray(raw) ? raw : [])
+        .filter((s) => typeof s?.file === "string" && typeof s?.code === "string" && s.code.trim())
+        .map((s) => ({ file: path.relative(process.cwd(), path.resolve(s.file)).split(path.sep).join("/"), line: Math.max(1, Math.floor(Number(s.line) || 1)), code: s.code.replace(/\r\n/g, "\n").replace(/\n+$/, ""), why: String(s.why ?? "") }));
+}
+/** The fenced block other engines (which can't call Nou's tools) put their steps in. */
+const BLOCK = /```nou-steps\s*\n([\s\S]*?)\n```/;
+/**
+ * The message that asks for steps. Nou's own engine hands them back with the show_steps tool; Claude
+ * Code, Codex and pi can't call Nou's tools, so they end their reply with a ```nou-steps block instead.
+ */
+export function showMePrompt(task, withTool) {
+    const how = withTool
+        ? `call ${SHOW_STEPS} once with the steps in order`
+        : "end your reply with the steps in order as a JSON array in a fenced block marked nou-steps, like:\n```nou-steps\n[{\"file\": \"src/cli.ts\", \"line\": 12, \"code\": \"const verbose = args.includes(\\\"--verbose\\\");\", \"why\": \"Reads the new flag.\"}]\n```";
+    return `[Show me how] ${task}\n\nDon't edit any files: I want to type it myself. Read what you need to find where it goes, then ${how} (each step: file, the line to add the code before, the exact lines of code to type, and why). Keep each step small, a few lines, so it's easy to follow.`;
+}
+/** Steps from a reply's ```nou-steps block, and the reply without it; null when there's none. */
+export function stepsFromReply(text) {
+    const m = BLOCK.exec(text);
+    if (!m)
+        return null;
+    try {
+        const steps = tidySteps(JSON.parse(m[1]));
+        return steps.length ? { steps, rest: text.replace(m[0], "").trim() } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * How far the text typed so far (`typed`, from where the step starts to the cursor) gets through
+ * `expected`: the index reached in `expected`, or -1 when it doesn't match. Leading indentation on each
+ * line is ignored either way, since the editor indents new lines itself.
+ */
+export function guideProgress(typed, expected) {
+    let i = 0;
+    let j = 0;
+    const skipIndent = (s, k) => {
+        while (k < s.length && (s[k] === " " || s[k] === "\t"))
+            k++;
+        return k;
+    };
+    i = skipIndent(typed, i);
+    j = skipIndent(expected, j);
+    while (i < typed.length) {
+        if (j >= expected.length || typed[i] !== expected[j])
+            return -1;
+        const newline = typed[i] === "\n";
+        i++;
+        j++;
+        if (newline) {
+            i = skipIndent(typed, i);
+            // The rest of the expected indentation counts as typed only once something follows it.
+            if (i < typed.length)
+                j = skipIndent(expected, j);
+        }
+    }
+    return j;
+}

package/dist/src/syntax/index.js

@@ -101,28 +101,27 @@ const CALLS = /^(call_expression|call|method_invocation|new_expression)$/;
 /** A named string node (anonymous keyword nodes can also be called "string", e.g. the TS type). */
 const isString = (n) => n.isNamed && STRINGS.test(n.type);
 const hasSubstitution = (n) => n.children.some((c) => c !== null && /substitution|interpolation/.test(c.type));
-function colorFor(node) {
+/**
+ * The color of a leaf. Its `parent` and `grand`parent and whether it's `inString` come from the walk over
+ * the tree: asking the node for them (node.parent) crosses into wasm, and every token used to, several times.
+ */
+function colorFor(node, parent, grand, inString) {
     const type = node.type;
     if (type.includes("comment"))
         return "comment";
     // Inside a string (but not inside ${...} substitutions)?
-    for (let p = node; p; p = p.parent) {
-        if (/substitution|interpolation/.test(p.type))
-            break;
-        if (isString(p))
-            return "string";
-    }
+    if (inString || isString(node))
+        return "string";
     // Built-in type names (`number`, `string`) and Python annotations (`name: str`).
-    if (node.parent?.type === "predefined_type" || (node.parent?.type === "type" && /identifier$/.test(type)))
+    if (parent?.type === "predefined_type" || (parent?.type === "type" && /identifier$/.test(type)))
         return "type";
     if (NUMBERS.test(type))
         return "number";
     if (CONSTANTS.test(type) || CONSTANTS.test(node.text))
         return node.isNamed || /^[a-zA-Z]+$/.test(node.text) ? "constant" : null;
-    if (TYPES.test(type) && (node.isNamed || node.parent?.type === "predefined_type"))
+    if (TYPES.test(type) && (node.isNamed || parent?.type === "predefined_type"))
         return "type";
     if (/identifier$/.test(type)) {
-        const parent = node.parent;
         if (parent && FUNCTION_PARENTS.test(parent.type) && parent.childForFieldName("name")?.equals(node))
             return "func";
         if (parent && CALLS.test(parent.type) && parent.childForFieldName("function")?.equals(node))
@@ -131,7 +130,7 @@ function colorFor(node) {
         const member = parent && /member_expression|attribute|field_expression|selector_expression/.test(parent.type)
             ? parent.childForFieldName("property") ?? parent.childForFieldName("attribute") ?? parent.childForFieldName("field")
             : null;
-        if (member?.equals(node) && parent.parent && CALLS.test(parent.parent.type) && parent.parent.childForFieldName("function")?.equals(parent))
+        if (member?.equals(node) && grand && CALLS.test(grand.type) && grand.childForFieldName("function")?.equals(parent))
             return "func";
     }
     if (PROPERTIES.test(type))
@@ -146,7 +145,7 @@ function colorFor(node) {
         return null;
     }
     if (!node.isNamed) {
-        if (node.parent?.type === "predefined_type")
+        if (parent?.type === "predefined_type")
             return "type";
         return /^[a-z_]+$/i.test(type) ? "keyword" : "punctuation";
     }
@@ -162,14 +161,14 @@ export function highlightTree(file, text) {
     let out = "";
     let pos = 0;
     const cursor = tree.walk();
-    // Depth-first over leaves, coloring each span.
-    const visit = () => {
+    // Depth-first over leaves, coloring each span; each level knows its parent, grandparent and whether it's in a string.
+    const visit = (parent, grand, inString) => {
         do {
             const node = cursor.currentNode;
             if (node.childCount === 0 || node.type.includes("comment") || (isString(node) && !hasSubstitution(node))) {
                 if (node.startIndex >= pos) {
                     out += themeColors().plain(text.slice(pos, node.startIndex));
-                    const color = colorFor(node);
+                    const color = colorFor(node, parent, grand, inString);
                     const span = text.slice(node.startIndex, node.endIndex);
                     // Color each line separately so styles don't bleed across line breaks.
                     out += span.split("\n").map((part) => (color ? themeColors()[color](part) : themeColors().plain(part))).join("\n");
@@ -177,13 +176,14 @@ export function highlightTree(file, text) {
                 }
             }
             else if (cursor.gotoFirstChild()) {
-                visit();
+                // A ${...} substitution inside a string starts code again.
+                visit(node, parent, /substitution|interpolation/.test(node.type) ? false : inString || isString(node));
                 cursor.gotoParent();
             }
         } while (cursor.gotoNextSibling());
     };
     if (cursor.gotoFirstChild())
-        visit();
+        visit(tree.rootNode, null, false);
     out += themeColors().plain(text.slice(pos));
     tree.delete();
     return out.split("\n");