@thispointon/kondi-chat 0.1.2 → 0.1.3

package/bin/kondi-chat

@@ -5,7 +5,7 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
-VERSION="0.1.2"
+VERSION="0.1.3"
 
 if [[ "${1:-}" == "--version" || "${1:-}" == "-V" ]]; then
   echo "kondi-chat $VERSION"

package/bin/kondi-chat.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const projectRoot = join(__dirname, "..");
-const version = "0.1.2";
+const version = "0.1.3";
 
 const arg = process.argv[2];
 
@@ -49,7 +50,11 @@ if (arg === "--help" || arg === "-h") {
   process.exit(0);
 }
 
-const tuiBinary = join(projectRoot, "tui", "target", "release", "kondi-tui");
+// Windows postinstall writes kondi-tui.exe; POSIX writes kondi-tui.
+const tuiBinary = join(
+  projectRoot, "tui", "target", "release",
+  process.platform === "win32" ? "kondi-tui.exe" : "kondi-tui",
+);
 
 if (existsSync(tuiBinary)) {
   try {
@@ -58,12 +63,31 @@ if (existsSync(tuiBinary)) {
     process.exit(e.status ?? 1);
   }
 } else {
-  // Run the Node backend from the user's current working directory — NOT from
-  // the install dir. Setting cwd: projectRoot here would make the agent operate
-  // on the kondi-chat install instead of the user's project, which was the
-  // common failure mode for any install where the TUI binary download failed.
+  // No prebuilt TUI binary — run the Node backend directly. Resolve the
+  // package-local `tsx` (a declared dependency) and run it with the current
+  // Node, instead of `npx tsx`: in a global install `npx` can't see the
+  // package's local tsx and prompts to install it. execFileSync with an
+  // argv array also avoids shell quoting issues with user args on Windows.
+  //
+  // cwd is intentionally NOT set to projectRoot — the backend must operate
+  // on the user's working directory, not the kondi-chat install dir.
+  const backend = join(projectRoot, "src", "cli", "backend.ts");
+  let tsxCli;
   try {
-    execSync(`npx tsx ${join(projectRoot, "src", "cli", "backend.ts")} ${process.argv.slice(2).join(" ")}`, {
+    const require = createRequire(import.meta.url);
+    const tsxPkgPath = require.resolve("tsx/package.json");
+    const tsxPkg = JSON.parse(readFileSync(tsxPkgPath, "utf-8"));
+    const binRel = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin.tsx;
+    tsxCli = join(dirname(tsxPkgPath), binRel);
+  } catch {
+    console.error(
+      "kondi-chat: could not locate the 'tsx' runtime inside the package. " +
+      "Try reinstalling: npm install -g @thispointon/kondi-chat",
+    );
+    process.exit(1);
+  }
+  try {
+    execFileSync(process.execPath, [tsxCli, backend, ...process.argv.slice(2)], {
       stdio: "inherit",
     });
   } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thispointon/kondi-chat",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Multi-model AI coding CLI with intelligent routing, budget profiles, and council deliberation",
   "license": "MIT",
   "type": "module",

package/src/cli/backend.ts

@@ -100,7 +100,7 @@ async function main() {
   // Spec 16 — first-run setup wizard (non-interactive; safe on every start).
   runFirstRunWizard(storageDir);
   // Spec 16 — async update check; swallow failures. Don't block startup.
-  checkForUpdate('0.1.2').then(b => { if (b) emit({ type: 'status', text: b }); }).catch(() => {});
+  checkForUpdate('0.1.3').then(b => { if (b) emit({ type: 'status', text: b }); }).catch(() => {});
 
   // Spec 06 — session resume
   const sessionStore = new SessionStore(storageDir);

package/src/context/bootstrap.ts

@@ -5,9 +5,9 @@
  * Based on kondi-council's context-bootstrap.ts — simplified, two-tier.
  */
 
-import { execSync } from 'node:child_process';
 import { readFileSync, existsSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { join, resolve, relative, isAbsolute } from 'node:path';
+import { walkFiles } from '../util/fs-walk.ts';
 
 const MAX_FILE_SIZE = 2048;
 
@@ -54,19 +54,11 @@ export async function bootstrapDirectory(
     let fileList: string[] = [];
 
     try {
-      const raw = execSync(
-        `find . -maxdepth 4 -type f ` +
-        `-not -path '*/node_modules/*' -not -path '*/.git/*' ` +
-        `-not -path '*/target/*' -not -path '*/__pycache__/*' ` +
-        `-not -path '*/.next/*' -not -path '*/dist/*' ` +
-        `-not -path '*/package-lock.json' ` +
-        `| sort | head -${maxFiles}`,
-        { cwd: workingDir, encoding: 'utf-8', timeout: 10_000 },
-      ).trim();
-      tree = raw;
-      fileList = raw.split('\n').filter(Boolean);
+      fileList = walkFiles(workingDir, { maxDepth: 4, maxFiles })
+        .filter(f => f !== 'package-lock.json' && !f.endsWith('/package-lock.json'));
+      tree = fileList.join('\n');
     } catch {
-      // find failed, continue
+      // walk failed, continue
     }
 
     const files: Array<{ name: string; content: string }> = [];
@@ -125,9 +117,12 @@ export async function bootstrapDirectory(
 
 function safeRead(workingDir: string, base: string, fileName: string, maxSize: number): string | null {
   try {
-    const filePath = join(workingDir.replace(/\/$/, ''), fileName);
+    const filePath = join(workingDir, fileName);
     const resolved = resolve(filePath);
-    if (!resolved.startsWith(base + '/') && resolved !== base) return null;
+    // Cross-platform containment check — `startsWith(base + '/')` breaks on
+    // Windows backslash paths. relative() is separator-agnostic.
+    const rel = relative(base, resolved);
+    if (rel !== '' && (rel.startsWith('..') || isAbsolute(rel))) return null;
     if (!existsSync(filePath)) return null;
     const content = readFileSync(filePath, 'utf-8');
     if (!content) return null;

package/src/engine/tools.ts

@@ -15,7 +15,8 @@ function isPathSafe(base: string, fullPath: string): boolean {
   const rel = relative(base, fullPath);
   return !rel.startsWith('..') && !resolve(fullPath).includes('\0');
 }
-import { execSync, execFileSync } from 'node:child_process';
+import { execSync } from 'node:child_process';
+import { walkFiles } from '../util/fs-walk.ts';
 import type { ToolDefinition, Session, TaskKind } from '../types.ts';
 import type { Ledger } from '../audit/ledger.ts';
 import { runPipeline, type PipelineConfig } from './pipeline.ts';
@@ -503,15 +504,8 @@ function toolListFiles(
 
   if (recursive) {
     try {
-      const output = execSync(
-        `find . -maxdepth 4 -type f ` +
-        `-not -path '*/node_modules/*' -not -path '*/.git/*' ` +
-        `-not -path '*/target/*' -not -path '*/__pycache__/*' ` +
-        `-not -path '*/.next/*' -not -path '*/dist/*' ` +
-        `| sort | head -100`,
-        { cwd: fullPath, encoding: 'utf-8', timeout: 10_000 },
-      ).trim();
-      return { content: output || '(empty directory)' };
+      const files = walkFiles(fullPath, { maxDepth: 4, maxFiles: 100 });
+      return { content: files.join('\n') || '(empty directory)' };
     } catch {
       return { content: '(failed to list files)', isError: true };
     }
@@ -546,41 +540,61 @@ function toolSearchCode(
 
   // process.stderr.write(`[tool] search_code: "${pattern}" in ${relPath}\n`);
 
-  // Sanitize glob (defense-in-depth even though execFileSync skips the shell).
-  const safeGlob = glob ? glob.replace(/[^a-zA-Z0-9.*?_\-\/]/g, '') : '';
-  const grepArgs: string[] = [
-    '-rnE',                       // recursive, line numbers, extended regex
-    '--exclude-dir=node_modules',
-    '--exclude-dir=.git',
-  ];
-  if (safeGlob) grepArgs.push(`--include=${safeGlob}`);
-  grepArgs.push('-e', pattern, searchPath);
+  // Cross-platform content search — pure Node, no `grep` (absent on Windows).
+  let regex: RegExp;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    return {
+      content: `Invalid regex: ${pattern} — could not compile it. Escape special characters or simplify the pattern.`,
+      isError: true,
+    };
+  }
 
+  // Optional filename glob → a basename matcher.
+  let nameMatches: ((name: string) => boolean) | null = null;
+  if (glob) {
+    const safeGlob = glob.replace(/[^a-zA-Z0-9.*?_\-\/]/g, '');
+    if (safeGlob) {
+      const rx = '^' + safeGlob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.') + '$';
+      const globRe = new RegExp(rx);
+      nameMatches = (name: string) => globRe.test(name);
+    }
+  }
+
+  const MAX_MATCHES = 50;
+  const results: string[] = [];
+  let files: string[];
   try {
-    const raw = execFileSync('grep', grepArgs, {
-      encoding: 'utf-8',
-      timeout: 15_000,
-      cwd: ctx.workingDir,
-      maxBuffer: 4 * 1024 * 1024,
-    });
-    const lines = raw.split('\n');
-    const head = lines.slice(0, 50).join('\n').trim();
-    return { content: head || 'No matches found.' };
+    files = walkFiles(searchPath, { maxDepth: 12, maxFiles: 5000 });
   } catch (error: any) {
-    // grep returns exit code 1 for no matches.
-    if (error.status === 1) {
-      return { content: 'No matches found.' };
+    return { content: `Search error: ${error.message}`, isError: true };
+  }
+
+  for (const rel of files) {
+    if (results.length >= MAX_MATCHES) break;
+    const fileName = rel.split('/').pop() || rel;
+    if (nameMatches && !nameMatches(fileName)) continue;
+    let buf: Buffer;
+    try {
+      buf = readFileSync(join(searchPath, rel));
+    } catch {
+      continue;
     }
-    // Exit 2 = invalid regex / IO error. Surface a useful message rather
-    // than the raw shell complaint so the model can correct its pattern.
-    if (error.status === 2) {
-      return {
-        content: `Invalid regex: ${pattern} — grep -E rejected it. Try escaping special chars or use search_files for a literal lookup.`,
-        isError: true,
-      };
+    if (buf.includes(0)) continue; // skip binary files
+    const lines = buf.toString('utf-8').split('\n');
+    for (let i = 0; i < lines.length && results.length < MAX_MATCHES; i++) {
+      if (regex.test(lines[i])) {
+        const text = lines[i].length > 240 ? lines[i].slice(0, 240) + '…' : lines[i];
+        results.push(`${rel}:${i + 1}:${text}`);
+      }
     }
-    return { content: `Search error: ${error.message}`, isError: true };
   }
+
+  return { content: results.length > 0 ? results.join('\n') : 'No matches found.' };
 }
 
 function toolRunCommand(

package/src/util/fs-walk.ts

@@ -0,0 +1,55 @@
+/**
+ * Cross-platform recursive file walk.
+ *
+ * Replaces Unix `find ... | sort | head` pipelines, which fail on Windows
+ * (`head` / `grep` don't exist, `find` differs). Pure Node `fs` — behaves
+ * identically on Windows and POSIX.
+ */
+
+import { readdirSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+
+export interface WalkOptions {
+  /** Max directory depth — files directly in root are depth 1. Default 4. */
+  maxDepth?: number;
+  /** Stop after collecting this many files. Default 100. */
+  maxFiles?: number;
+  /** Directory names to skip entirely. */
+  excludeDirs?: string[];
+}
+
+const DEFAULT_EXCLUDES = ['node_modules', '.git', 'target', '__pycache__', '.next', 'dist'];
+
+/**
+ * Walk `root` recursively. Returns file paths relative to `root`, using
+ * forward slashes on every platform, sorted, and capped at `maxFiles`.
+ */
+export function walkFiles(root: string, opts: WalkOptions = {}): string[] {
+  const maxDepth = opts.maxDepth ?? 4;
+  const maxFiles = opts.maxFiles ?? 100;
+  const exclude = new Set(opts.excludeDirs ?? DEFAULT_EXCLUDES);
+  const out: string[] = [];
+
+  const walk = (dir: string, depth: number): void => {
+    if (out.length >= maxFiles || depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return; // unreadable directory — skip
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      if (out.length >= maxFiles) return;
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!exclude.has(e.name)) walk(full, depth + 1);
+      } else if (e.isFile()) {
+        out.push(relative(root, full).split(sep).join('/'));
+      }
+    }
+  };
+
+  walk(root, 1);
+  return out;
+}