@polylogicai/polycode 1.1.1 → 1.1.3

package/README.md

@@ -4,21 +4,37 @@ An agentic coding CLI. Runs on your machine with your keys. Every turn is append
 
 ## Install
 
+The fastest way to try polycode is with `npx`. It works on macOS, Linux, and Windows from any terminal:
+
+```bash
+npx @polylogicai/polycode@latest
+```
+
+For repeated use, install it globally:
+
 ```bash
 npm install -g @polylogicai/polycode
+polycode
 ```
 
 ## Quick start
 
+Set your Groq API key, then run polycode:
+
 ```bash
+# macOS and Linux
 export GROQ_API_KEY=gsk_...
-polycode
+npx @polylogicai/polycode@latest
+
+# Windows PowerShell
+$env:GROQ_API_KEY = "gsk_..."
+npx @polylogicai/polycode@latest
 ```
 
 That opens an interactive session. For one-shot mode, pass your prompt as an argument:
 
 ```bash
-polycode "read README.md and summarize it in one sentence"
+npx @polylogicai/polycode@latest "read README.md and summarize it in one sentence"
 ```
 
 A free Groq API key is available at `console.groq.com`.
@@ -92,7 +108,7 @@ Rules live in `~/.polycode/rules.yaml`. You can add your own.
 ## Requirements
 
 - Node.js 20 or newer
-- macOS or Linux
+- macOS, Linux, or Windows
 - A Groq API key
 
 ## Documentation and support

package/bin/polycode.mjs

@@ -19,6 +19,11 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'no
 import { homedir } from 'node:os';
 import { join, dirname, resolve } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_JSON = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
 import * as readline from 'node:readline/promises';
 import { stdin, stdout, exit, argv, env, cwd as getCwd } from 'node:process';
 import 'dotenv/config';
@@ -137,7 +142,7 @@ function loadRules() {
   return {};
 }
 
-const VERSION = '1.1.0';
+const VERSION = PACKAGE_JSON.version;
 const DOCS_URL = 'https://polylogicai.com/polycode';
 
 const BANNER = `${C.bold}${C.amber}polycode v${VERSION}${C.reset}

package/lib/agentic.mjs

@@ -13,12 +13,62 @@ import Groq from 'groq-sdk';
 import { promises as fs } from 'node:fs';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
-import { resolve, relative, sep, dirname } from 'node:path';
+import { resolve, relative, sep, dirname, join, basename } from 'node:path';
 import { compilePacket } from './compiler.mjs';
 import { mintCommitment } from './commitment.mjs';
 import { ensureActiveIntent } from './intent.mjs';
 import { scrubSecrets } from './witness/secret-scrubber.mjs';
 
+// Cross-platform directory walker. Pure Node.js, no shell-out. Skips common
+// noise directories (node_modules, .git, etc.) by default. Yields absolute
+// file paths as an async iterator so callers can bail out early.
+export const DEFAULT_SKIP_DIRS = new Set(['node_modules', '.git', '.svn', '.hg', 'dist', 'build', '.next', '.nuxt']);
+
+export async function* walkFiles(root, skipDirs = DEFAULT_SKIP_DIRS) {
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (skipDirs.has(entry.name) || entry.name.startsWith('.DS_Store')) continue;
+    const fullPath = join(root, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkFiles(fullPath, skipDirs);
+    } else if (entry.isFile()) {
+      yield fullPath;
+    }
+  }
+}
+
+// Minimal glob-to-regex converter. Supports ** (any depth), * (any chars
+// except /), ? (one char). Anchors the pattern with ^ and $ so callers get
+// full-string matching.
+export function globToRegex(pattern) {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*\//g, '\u0001')
+    .replace(/\*\*/g, '\u0001')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]')
+    .replace(/\u0001/g, '(?:.*/)?');
+  return new RegExp('^' + escaped + '$');
+}
+
+// Normalize a filesystem path to forward slashes so glob matching and output
+// formatting behave the same on every platform.
+export function toPosix(p) {
+  return sep === '/' ? p : p.split(sep).join('/');
+}
+
+// Detect whether a file buffer is likely binary by looking for a NUL byte in
+// the first kilobyte. Used by the grep tool to skip binary files.
+export function looksBinary(content) {
+  const head = content.slice(0, 1024);
+  return head.indexOf('\u0000') !== -1;
+}
+
 const execAsync = promisify(exec);
 
 const DEFAULT_MODEL = 'moonshotai/kimi-k2-instruct';
@@ -95,7 +145,7 @@ const TOOL_SCHEMAS = [
     type: 'function',
     function: {
       name: 'bash',
-      description: 'Run a shell command in the working directory. 30 second timeout. Output truncated at 3200 bytes.',
+      description: 'Run a shell command in the working directory. Uses the system default shell, so assume POSIX tools on macOS and Linux and cmd.exe on Windows. Prefer read_file, write_file, edit_file, glob, and grep for file operations; reserve this tool for real commands like running tests or git. 30 second timeout. Output truncated at 3200 bytes.',
       parameters: {
         type: 'object',
         properties: { command: { type: 'string' } },
@@ -239,23 +289,57 @@ async function runTool(name, args, cwd) {
       }
     }
     case 'glob': {
-      const pattern = String(args.pattern ?? '').replace(/'/g, "'\\''");
+      const pattern = String(args.pattern ?? '').trim();
+      if (!pattern) return '(no pattern)';
       try {
-        const { stdout } = await execAsync(`find . -type f -name '${pattern}' 2>/dev/null | head -200`, { cwd });
-        return truncateStr(stdout || '(no matches)');
+        const regex = globToRegex(pattern);
+        const matches = [];
+        for await (const fullPath of walkFiles(cwd)) {
+          const rel = toPosix(relative(cwd, fullPath));
+          if (regex.test(rel) || regex.test(basename(fullPath))) {
+            matches.push('./' + rel);
+            if (matches.length >= 200) break;
+          }
+        }
+        if (matches.length === 0) return '(no matches)';
+        return truncateStr(matches.join('\n'));
       } catch (err) {
         return `error: ${err.message}`;
       }
     }
     case 'grep': {
-      const pattern = String(args.pattern ?? '').replace(/'/g, "'\\''");
-      const glob = String(args.glob ?? '').replace(/'/g, "'\\''");
+      const pattern = String(args.pattern ?? '').trim();
+      if (!pattern) return '(no pattern)';
+      let regex;
       try {
-        const cmd = glob
-          ? `grep -rn --include='${glob}' -E '${pattern}' . 2>/dev/null | head -100`
-          : `grep -rn -E '${pattern}' . 2>/dev/null | head -100`;
-        const { stdout } = await execAsync(cmd, { cwd });
-        return truncateStr(stdout || '(no matches)');
+        regex = new RegExp(pattern);
+      } catch (err) {
+        return `error: invalid regex: ${err.message}`;
+      }
+      const globPattern = String(args.glob ?? '').trim();
+      const globRegex = globPattern ? globToRegex(globPattern) : null;
+      const matches = [];
+      try {
+        outer: for await (const fullPath of walkFiles(cwd)) {
+          const rel = toPosix(relative(cwd, fullPath));
+          if (globRegex && !(globRegex.test(rel) || globRegex.test(basename(fullPath)))) continue;
+          let content;
+          try {
+            content = await fs.readFile(fullPath, 'utf8');
+          } catch {
+            continue;
+          }
+          if (looksBinary(content)) continue;
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              matches.push(`./${rel}:${i + 1}:${lines[i].slice(0, 200)}`);
+              if (matches.length >= 100) break outer;
+            }
+          }
+        }
+        if (matches.length === 0) return '(no matches)';
+        return truncateStr(matches.join('\n'));
       } catch (err) {
         return `error: ${err.message}`;
       }

package/lib/hooks.mjs

@@ -72,11 +72,17 @@ export async function fireHook(eventName, payload, hookDir) {
   const isShell = hookPath.endsWith('.sh') || !hookPath.includes('.');
   const isNode = hookPath.endsWith('.mjs') || hookPath.endsWith('.js');
 
+  // On Windows we cannot spawn sh for POSIX shell hooks. Skip with a clear
+  // reason so the caller knows the hook did not run. Node hooks are portable.
+  if (isShell && process.platform === 'win32') {
+    return { action: 'allow', reason: 'shell hooks not supported on Windows; use .mjs' };
+  }
+
   return new Promise((resolveHook) => {
     let child;
     try {
       child = isNode
-        ? spawn('node', [hookPath], { stdio: ['pipe', 'pipe', 'pipe'] })
+        ? spawn(process.execPath, [hookPath], { stdio: ['pipe', 'pipe', 'pipe'] })
         : spawn('sh', [hookPath], { stdio: ['pipe', 'pipe', 'pipe'] });
     } catch (err) {
       resolveHook({ action: 'allow', reason: `spawn failed: ${err.message}` });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylogicai/polycode",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "An agentic coding CLI. Runs on your machine with your keys. Every turn is appended to a SHA-256 chained session log, so your history is auditable, replayable, and portable.",
   "type": "module",
   "main": "bin/polycode.mjs",