chore: sync and update various features and documentation

Author: shaglama

nitpick-mcp/nitpick_mcp.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+import sys
+import json
+import subprocess
+import time
+
+mcp_script = "./nitpick_mcp.py"
+
+p = subprocess.Popen(
+    ["python3", mcp_script],
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    text=True
+)
+
+def send_request(method, params, req_id):
+    req = {
+        "jsonrpc": "2.0",
+        "id": req_id,
+        "method": method,
+        "params": params
+    }
+    p.stdin.write(json.dumps(req) + "\n")
+    p.stdin.flush()
+    line = p.stdout.readline()
+    if not line:
+        return None
+    return json.loads(line)
+
+try:
+    print("Testing initialize...")
+    res = send_request("initialize", {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name":"test","version":"1"}}, 1)
+    assert res is not None, "Failed to get response"
+    assert "result" in res, f"Expected result in {res}"
+
+    # After initialize, the server sends an initialized notification?
+    # Actually client sends initialized notification.
+    notif = {
+        "jsonrpc": "2.0",
+        "method": "notifications/initialized",
+        "params": {}
+    }
+    p.stdin.write(json.dumps(notif) + "\n")
+    p.stdin.flush()
+
+    print("Testing tools/list...")
+    res = send_request("tools/list", {}, 2)
+    assert res is not None, "Failed to get response"
+    assert "result" in res, f"Expected result in {res}"
+    tools = res["result"]["tools"]
+    tool_names = [t["name"] for t in tools]
+    assert "nitpick_compile" in tool_names
+    assert "nitpick_check" in tool_names
+    assert "nitpick_docs" in tool_names
+
+    print("All MCP tests passed!")
+finally:
+    p.terminate()

nitpick-mcp/test_mcp.py

@@ -52,15 +52,4 @@ src/parser.npk:91:   [RAW]      raw() strips Result<T> — caller must handle fa
 | `1`  | One or more findings present  |
 | `2`  | Usage error or no files found |
 
-## v1 Limitations
 
-- `//` comment stripping is naive and does not account for `//` inside string literals
-- Brace counting for `failsafe` block triviality can be thrown off by unbalanced
-  `{` / `}` inside string literals within the block
-- Content placed on the same line as the `failsafe` opening brace (after the `{`)
-  is not checked for triviality in multi-line blocks
-- String literals are not excluded from pattern matching; a string containing
-  `raw(` or `wild` would be flagged
-
-These are all acceptable for a v1 review-aid tool. False positives require a
-quick human glance; false negatives for the edge cases above are rare in practice.

nitpick-safety/README.md

@@ -0,0 +1,21 @@
+func main() -> NIL:
+    // This is a comment with wild and raw(
+    let str1 = "This string has wild and raw( and { and }"
+    let str2 = `This is a 
+    multi-line string with wild and 
+    raw( and {
+    and // comments inside strings
+    }`
+    
+    // Test failsafe string triviality
+    failsafe {
+        pass("not trivial because string {");
+    }
+    
+    failsafe {
+        pass(NIL)
+    }
+
+    let a = wildx alloc(10) // should trigger
+    raw(a) // should trigger
+end

nitpick-safety/mock_file.npk

@@ -181,11 +181,38 @@ static void strip_nl(char *s)
     if (n > 0 && s[n - 1] == '\r') s[--n] = '\0';
 }
 
-/* Strip // line comment in-place.  Naive: does not handle // inside strings. */
-static void strip_line_comment(char *s)
+/* 
+ * mask_strings_and_comments: Masks string contents (replaces with space) to prevent
+ * false positive pattern/brace matches, and correctly strips // comments.
+ * Tracks quote state across lines to support multi-line strings.
+ */
+static void mask_strings_and_comments(char *s, int *in_quote)
 {
-    char *p = strstr(s, "//");
-    if (p) *p = '\0';
+    int escape = 0;
+    for (char *p = s; *p; p++) {
+        if (!*in_quote) {
+            if (*p == '/' && *(p+1) == '/') {
+                *p = '\0';
+                break;
+            }
+            if (*p == '"') *in_quote = 1;
+            else if (*p == '`') *in_quote = 2;
+        } else {
+            if (escape) {
+                *p = ' ';
+                escape = 0;
+            } else if (*p == '\\') {
+                *p = ' ';
+                escape = 1;
+            } else if ((*in_quote == 1 && *p == '"') || (*in_quote == 2 && *p == '`')) {
+                *in_quote = 0;
+            } else {
+                if (*p != '\n' && *p != '\r') {
+                    *p = ' ';
+                }
+            }
+        }
+    }
 }
 
 /*
@@ -228,13 +255,15 @@ static void scan_file(const char *path)
     int     fs_open_line = 0;   /* line where the opening '{' was found */
     int     fs_trivial   = 1;   /* cleared once we see non-trivial content */
 
+    int     in_quote     = 0;   /* string masking state: 0 = none, 1 = ", 2 = ` */
+
     while (fgets(raw, sizeof(raw), f)) {
         lineno++;
         strip_nl(raw);
 
         /* working copy: strip // comment so patterns don't fire in comments */
         memcpy(line, raw, strlen(raw) + 1);
-        strip_line_comment(line);
+        mask_strings_and_comments(line, &in_quote);
 
         /* first non-whitespace character */
         const char *trimmed = line;

nitpick-safety/nitpick-safety

@@ -0,0 +1,5 @@
+
+3 findings across 1 file
+mock_file.npk:15: [FAILSAFE] empty or trivial failsafe block — error is silently swallowed
+mock_file.npk:19: [WILD] wildx allocation — no GC, no bounds checking; manual lifetime required
+mock_file.npk:20: [RAW] raw() strips Result<T> — caller must handle failure explicitly

nitpick-safety/nitpick_safety.c

@@ -0,0 +1,51 @@
+#!/bin/bash
+set -e
+
+echo "Building nitpick-safety..."
+make
+
+echo "Creating mock_file.npk..."
+cat << 'EOF' > mock_file.npk
+func main() -> NIL:
+    // This is a comment with wild and raw(
+    let str1 = "This string has wild and raw( and { and }"
+    let str2 = `This is a 
+    multi-line string with wild and 
+    raw( and {
+    and // comments inside strings
+    }`
+    
+    // Test failsafe string triviality
+    failsafe {
+        pass("not trivial because string {");
+    }
+    
+    failsafe {
+        pass(NIL)
+    }
+
+    let a = wildx alloc(10) // should trigger
+    raw(a) // should trigger
+end
+EOF
+
+echo "Running nitpick-safety..."
+./nitpick-safety mock_file.npk > output.txt 2>&1 || true
+
+cat output.txt
+
+if grep -q "mock_file.npk:19: \[WILD\]" output.txt && grep -q "mock_file.npk:20: \[RAW\]" output.txt && grep -q "mock_file.npk:15: \[FAILSAFE\]" output.txt; then
+    echo "Expected hits found!"
+else
+    echo "Missing expected hits!"
+    exit 1
+fi
+
+if grep -q "str1" output.txt || grep -q "str2" output.txt || grep -q "multi-line" output.txt || grep -q "comment with wild" output.txt || grep -q "not trivial" output.txt; then
+    echo "False positives found inside strings/comments!"
+    exit 1
+else
+    echo "No false positives in strings/comments."
+fi
+
+echo "All tests passed!"

nitpick-safety/output.txt

@@ -0,0 +1,10 @@
+extern func:malloc = void*(uint64:size);
+
+func:failsafe = int32(tbb32:err) {
+    exit 1i32;
+};
+
+func:main = int32() {
+    malloc(1024u64);
+    return 0i32;
+};