@axplusb/kepler 2.0.0 → 2.0.3

package/src/tools/project-overview.mjs

@@ -8,6 +8,35 @@ import { buildProjectSkeleton } from '../context/skeleton.mjs';
 import { indexDir as getIndexDir } from '../core/paths.mjs';
 
 const RESOURCE_FILE = 'project-resource.json';
+
+/**
+ * Expand "~" and trim surrounding quotes/whitespace. Does NOT unescape shell
+ * meta characters — that is a separate, last-resort step done only if the
+ * literal path does not resolve.
+ */
+function normalizePathInput(p) {
+    let s = String(p || '').trim();
+    // Trim balanced surrounding quotes.
+    if ((s.startsWith('"') && s.endsWith('"')) ||
+        (s.startsWith("'") && s.endsWith("'"))) {
+        s = s.slice(1, -1);
+    }
+    // Tilde expansion (~ or ~/...).
+    if (s === '~' || s.startsWith('~/')) {
+        s = path.join(os.homedir(), s.slice(1));
+    }
+    return s;
+}
+
+/**
+ * Replace common shell escape sequences with their literal characters. Used
+ * as a fallback when the literal path does not resolve — the agent may have
+ * pasted a copy of what they would type at a shell prompt.
+ */
+function unescapeShellPath(p) {
+    return String(p || '').replace(/\\([ \t()&$;'"])/g, '$1');
+}
+
 const LANGUAGE_EXTENSIONS = new Map([
     ['.py', 'Python'],
     ['.js', 'JavaScript'],
@@ -280,6 +309,12 @@ export class ProjectRegistry {
         if (!rawPath) {
             throw new Error('get_project_overview requires a project path');
         }
+
+        // LLM sometimes passes shell-escaped paths ("Tarang\ Orca") or paths
+        // beginning with "~". Normalize defensively so the tool does not bounce
+        // back a "not found" error on a path that's correct apart from quoting.
+        rawPath = normalizePathInput(rawPath);
+
         if (!path.isAbsolute(rawPath)) {
             rawPath = path.resolve(process.cwd(), rawPath);
         }
@@ -288,7 +323,15 @@ export class ProjectRegistry {
         try {
             root = fs.realpathSync(rawPath);
         } catch {
-            throw new Error(`Project path not found: ${rawPath}`);
+            // Try the unescaped variant explicitly so the error message can
+            // tell the agent what it actually attempted.
+            const unescaped = unescapeShellPath(rawPath);
+            if (unescaped !== rawPath) {
+                try { root = fs.realpathSync(unescaped); }
+                catch { throw new Error(`Project path not found: ${rawPath} (also tried ${unescaped})`); }
+            } else {
+                throw new Error(`Project path not found: ${rawPath}`);
+            }
         }
         if (!fs.statSync(root).isDirectory()) {
             throw new Error(`Project path is not a directory: ${root}`);
@@ -377,25 +420,64 @@ export class ProjectRegistry {
         if (!rawPath) {
             if (root) return root;
             if (this.projects.size === 1) return this.resources()[0].root;
-            throw new Error('Path requires project_id when multiple or no projects are registered');
+            // Fall back to the first registered project when the model omits
+            // both path and project_id. Beats throwing on an inferable case.
+            const first = this.resources()[0];
+            if (first) return first.root;
+            throw new Error('No projects registered. Call get_project_overview first.');
         }
 
-        let candidate;
-        if (path.isAbsolute(rawPath)) {
-            candidate = canonicalizeCandidate(path.resolve(rawPath));
-        } else {
+        // LLM frequently passes shell-quoted paths copied from a terminal,
+        // e.g. "Tarang\ Orca/src/app/\(kepler\)/page.tsx". Normalize here so
+        // every tool benefits, not just get_project_overview.
+        rawPath = normalizePathInput(rawPath);
+
+        const buildCandidate = (input) => {
+            if (path.isAbsolute(input)) {
+                return canonicalizeCandidate(path.resolve(input));
+            }
             if (!root) {
-                if (this.projects.size !== 1) {
-                    throw new Error('Relative path requires project_id when multiple or no projects are registered');
+                if (this.projects.size === 1) {
+                    return canonicalizeCandidate(path.resolve(this.resources()[0].root, input));
                 }
-                root = this.resources()[0].root;
+                if (this.projects.size > 1) {
+                    throw new Error('Relative path requires project_id when multiple projects are registered. Pass project_id or use an absolute path.');
+                }
+                throw new Error('No projects registered. Call get_project_overview first.');
             }
-            candidate = canonicalizeCandidate(path.resolve(root, rawPath));
-        }
+            return canonicalizeCandidate(path.resolve(root, input));
+        };
 
-        const containingProject = [...this.projects.values()].find(({ resource }) =>
-            isWithin(resource.root, candidate)
+        let candidate = buildCandidate(rawPath);
+
+        const findContaining = (cand) => [...this.projects.values()].find(({ resource }) =>
+            isWithin(resource.root, cand)
         );
+
+        let containingProject = findContaining(candidate);
+
+        // Two reasons to try the unescaped variant:
+        //   (1) candidate is outside every project root (literal "Tarang\ Orca"
+        //       does not contain a real project), or
+        //   (2) candidate is inside a root but does not exist on disk because
+        //       a path segment like "\(kepler\)" only resolves once unescaped.
+        // We retry once on the unescaped form before raising.
+        const needsRetry = !containingProject ||
+                           (!allowMissing && !fs.existsSync(candidate));
+        if (needsRetry) {
+            const unescaped = unescapeShellPath(rawPath);
+            if (unescaped !== rawPath) {
+                try {
+                    const altCandidate = buildCandidate(unescaped);
+                    const altProject = findContaining(altCandidate);
+                    if (altProject && (allowMissing || fs.existsSync(altCandidate))) {
+                        candidate = altCandidate;
+                        containingProject = altProject;
+                    }
+                } catch { /* fall through to the original error */ }
+            }
+        }
+
         if (!containingProject) {
             throw new Error(`Path is outside registered project roots: ${rawPath}`);
         }
@@ -406,10 +488,21 @@ export class ProjectRegistry {
     }
 
     projectForPath(filePath) {
-        const candidate = canonicalizeCandidate(path.resolve(filePath));
-        return [...this.projects.values()].find(({ resource }) =>
+        const normalized = normalizePathInput(filePath);
+        const candidate = canonicalizeCandidate(path.resolve(normalized));
+        const direct = [...this.projects.values()].find(({ resource }) =>
             isWithin(resource.root, candidate)
-        ) || null;
+        );
+        if (direct) return direct;
+        // Same unescape fallback used in resolvePath.
+        const unescaped = unescapeShellPath(normalized);
+        if (unescaped !== normalized) {
+            const altCandidate = canonicalizeCandidate(path.resolve(unescaped));
+            return [...this.projects.values()].find(({ resource }) =>
+                isWithin(resource.root, altCandidate)
+            ) || null;
+        }
+        return null;
     }
 
     reset() {

package/src/ui/tool-card.mjs

@@ -22,7 +22,7 @@
  */
 
 import { paint, width as visibleWidth } from './palette.mjs';
-import { icon, toolFamily } from './icons.mjs';
+import { toolFamily } from './icons.mjs';
 import { term } from './term.mjs';
 import {
   toolDisplayLabel,
@@ -129,12 +129,20 @@ export function summarizeResult(tool, data) {
       return { text: head || 'ok', tone: 'success' };
     }
 
+    case 'analyze_code': {
+      // Backend returns "filename (N lines, ext)" — the filename already
+      // appears in the card head, so strip it and keep just the metadata.
+      const head = firstOutputLine(data);
+      const m = head.match(/\((\d+)\s+lines?,?\s+([^)]+)\)/);
+      if (m) return { text: `${m[1]} lines · ${m[2].trim()}`, tone: 'success' };
+      return { text: head.slice(0, 80) || 'done', tone: 'success' };
+    }
+
     case 'plan':
     case 'explore':
     case 'verify':
     case 'debug':
-    case 'refactor':
-    case 'analyze_code': {
+    case 'refactor': {
       const head = firstOutputLine(data).slice(0, 100);
       return { text: head || 'done', tone: 'success' };
     }
@@ -195,7 +203,15 @@ function tone(text, t) {
 // ── Card head (printed at invocation) ────────────────────────────────────
 
 /**
- * Render the leading half of a card — icon + colored label + args.
+ * Render the leading half of a card — colored verb + args.
+ *
+ * v2.0.3: dropped the leading tool icon (🔭/🛠️/⚙️). The label itself is a
+ * present-progressive verb so the line reads like prose:
+ *   "Reading src/ui/banner.mjs · lines 31-65 — 36 lines"
+ * The icon was decorative noise that broke the conversational feel.
+ * Mission report and sub-agent renderers still use the icons in their
+ * own contexts.
+ *
  * Width-aware: truncates args from the left when the line would overflow.
  */
 export function formatCardHead(tool, args, opts = {}) {
@@ -203,15 +219,14 @@ export function formatCardHead(tool, args, opts = {}) {
   const cols = opts.columns || term().columns || 120;
   const indent = opts.indent || '  ';
 
-  const iconText  = icon(tool);
   const label     = toolDisplayLabel(tool);
   const argsText  = formatArgs(tool, args, cwd);
 
-  const leadVisible = visibleWidth(`${indent}${iconText} ${label}`);
+  const leadVisible = visibleWidth(`${indent}${label}`);
   const budget = Math.max(20, cols - leadVisible - 4);
   const argsTruncated = truncateMiddle(argsText, budget);
 
-  const head = `${indent}${iconText} ${paintLabel(tool, label)}`;
+  const head = `${indent}${paintLabel(tool, label)}`;
   return argsTruncated ? `${head} ${argsTruncated}` : head;
 }
 
@@ -232,9 +247,12 @@ export function formatCard({ tool, args, result, durationMs, indent, columns, cw
 
   if (!summary.text && !duration) return head;
 
-  const arrow = paint.text.dim('→');
+  const arrow = paint.text.dim('—');
   const body  = summary.text ? tone(summary.text, summary.tone) : '';
-  const tail  = duration ? paint.text.dim(` · ${duration}`) : '';
+  // Hide the duration tail when the tool was effectively instant (<200ms).
+  // For fast reads, "1ms" / "0ms" was noise that broke the prose feel.
+  const showDuration = duration && (durationMs == null || durationMs >= 200);
+  const tail  = showDuration ? paint.text.dim(` · ${duration}`) : '';
 
   const candidate = `${head}  ${arrow} ${body}${tail}`;
   if (visibleWidth(candidate) <= cols) return candidate;