@worca/ui 0.42.0 → 0.43.0

package/app/styles.css

@@ -9241,7 +9241,10 @@ body.help-mode-active sl-tab {
   border-right: none;
 }
 
-/* File column header — sticky left, wider than data cells */
+/* File column header — sticky left, wider than data cells.
+   ``position: relative`` so the drag handle (.access-col-file-resizer)
+   can pin to the right edge with position:absolute. ``sticky`` already
+   establishes a containing block for absolute children. */
 .access-col-file-header {
   position: sticky;
   left: 0;
@@ -9254,6 +9257,37 @@ body.help-mode-active sl-tab {
   border-right: 2px solid var(--border, #e2e8f0);
 }
 
+/* Drag handle for resizing the file column. Pinned to the right edge of
+   the header; on pointerdown it captures the pointer and rewrites the
+   shared --fa-file-col-width CSS var on the .run-file-access root, which
+   the grid template + sticky cells both read so they move in lockstep. */
+.access-col-file-resizer {
+  position: absolute;
+  top: 0;
+  right: -3px;
+  width: 7px;
+  height: 100%;
+  cursor: col-resize;
+  user-select: none;
+  touch-action: none;
+  z-index: 5;
+  background: transparent;
+}
+
+.access-col-file-resizer:hover,
+.access-col-file-resizer--active {
+  background: rgba(59, 130, 246, 0.35);
+}
+
+/* Body-level cursor lock during a drag (set via JS) — keeps the cursor as
+   col-resize even when the pointer leaves the handle's 7px hit area, which
+   is otherwise easy to do at faster drag speeds. */
+.access-col-file-resizing,
+.access-col-file-resizing * {
+  cursor: col-resize !important;
+  user-select: none !important;
+}
+
 .access-col-header--collapsed {
   background: rgba(59, 130, 246, 0.06);
   color: #3b82f6;
@@ -9338,10 +9372,12 @@ body.help-mode-active sl-tab {
   justify-content: flex-start;
   gap: 6px;
   padding: 3px 8px;
-  /* One indent step == a dir's [chevron 18px + gap 6px], so a child's content
-     (file name, or sub-folder chevron) starts exactly under its parent's
-     folder icon. */
-  padding-left: calc(8px + var(--depth, 0) * 24px);
+  /* One indent step == the full chevron + folder-icon prefix on a dir row:
+     chevron 18px + gap 6px + folder-icon 14px + gap 6px = 44px. A child file
+     row (no chevron/folder prefix) lands its name at exactly the x-position
+     of its parent folder's name, and a nested dir row's text aligns with
+     its grandparent's text — what a treegrid is supposed to look like. */
+  padding-left: calc(8px + var(--depth, 0) * 44px);
   background: inherit;
   border-right: 2px solid var(--border, #e2e8f0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/server/file-access-aggregator.js

@@ -361,6 +361,14 @@ function fragmentRecordsToFileAccess(records, repoRoot) {
  * Relativise an absolute fragment path against the repo root (a live stand-in
  * for the Python GitPathOracle respelling). Paths already relative, or outside
  * the repo, are returned unchanged; the repo root itself maps to null.
+ *
+ * Tolerant recovery: when ``repoRoot`` is a worktree under
+ * ``<project>/.worktrees/<id>`` and ``rawPath`` is an absolute path pointing
+ * at a sibling clone of the same project (e.g. the main checkout), strip the
+ * prefix up to and including the project basename so the entry groups under
+ * the project tree instead of rendering the full absolute path. Mirrors the
+ * Python ``_recover_basename_tail`` in ``path_canon.py`` so live and
+ * completion-time views agree.
  */
 function canonicalizePath(rawPath, repoRoot) {
   if (!rawPath) return null;
@@ -368,7 +376,31 @@ function canonicalizePath(rawPath, repoRoot) {
     return rawPath.slice(repoRoot.length + 1);
   }
   if (rawPath === repoRoot) return null;
-  return rawPath;
+  return recoverWorktreeBasenameTail(rawPath, repoRoot) ?? rawPath;
+}
+
+/**
+ * Recover repo-relative tail from a raw absolute path that fell outside a
+ * worktree root. Returns null when the heuristic doesn't apply so the caller
+ * can fall back to the raw path unchanged.
+ */
+function recoverWorktreeBasenameTail(rawPath, repoRoot) {
+  if (!rawPath || !repoRoot) return null;
+  const rootParts = repoRoot.split('/');
+  const wtIdx = rootParts.indexOf('.worktrees');
+  if (wtIdx <= 0) return null;
+  const projectBasename = rootParts[wtIdx - 1];
+  if (!projectBasename) return null;
+  const rawParts = rawPath.split('/');
+  // Scan from the right — the tail closest to the leaf is the most likely
+  // intended target when the basename appears more than once.
+  for (let i = rawParts.length - 1; i >= 0; i--) {
+    if (rawParts[i] === projectBasename) {
+      const tail = rawParts.slice(i + 1).join('/');
+      return tail || null;
+    }
+  }
+  return null;
 }
 
 function ensureFile(fileData, path) {
@@ -451,7 +483,47 @@ function buildTree(fileData) {
 
   // Rollup dir totals and cells bottom-up, then serialise to arrays.
   rollupDir(root);
-  return [...root.children.values()].map(serializeNode);
+  return collapseSingleChildDirs(
+    [...root.children.values()].map(serializeNode),
+  );
+}
+
+/**
+ * Collapse chains of single-child intermediate directories into one synthetic
+ * node. Without this, a stray absolute path (e.g. /Volumes/Apps/dev/.../foo.js)
+ * renders as a six-deep chain of single-row dirs that buries the filename.
+ *
+ * Rule: walk bottom-up, then while a dir's only child is also a dir, merge:
+ * adopt the child's children/cells/totals (which equal the parent's, since
+ * the parent rolled up from the single child) and visually concatenate the
+ * names so the collapsed segments stay visible without burning rows.
+ *
+ * The collapsed node keeps the deeper child's ``path`` so per-file drawer
+ * lookups (which key on the file's full path) continue to work.
+ */
+function collapseSingleChildDirs(nodes) {
+  return nodes.map(collapseNode);
+}
+
+function collapseNode(node) {
+  if (node.type !== 'dir') return node;
+  // Recurse first so the rule applies bottom-up.
+  let current = { ...node, children: node.children.map(collapseNode) };
+  while (current.children.length === 1 && current.children[0].type === 'dir') {
+    const child = current.children[0];
+    current = {
+      ...current,
+      path: child.path,
+      name: `${current.name}/${child.name}`,
+      children: child.children,
+      // cells/totals of a parent with a single dir child equal the child's
+      // (rollup invariant), so adopting the child's keeps the row identical
+      // to what it would have rendered before the collapse.
+      cells: child.cells,
+      totals: child.totals,
+    };
+  }
+  return current;
 }
 
 function rollupDir(node) {

package/server/templates-routes.js

@@ -313,6 +313,12 @@ function exportBundle(projectRoot, id, mode = 'standalone') {
   const dir = mkdtempSync(join(tmpdir(), 'worca-bundle-'));
   try {
     const bundlePath = join(dir, `${id}-bundle.out`);
+    // --include-models / --include-pricing: bundle the project's worca.models
+    // and worca.pricing entries that the template references (e.g. a custom
+    // "glm-ds" alias). The CLI already filters to *referenced* aliases via
+    // collect_referenced_model_aliases, so built-ins the importer already has
+    // (opus/sonnet/haiku) aren't shipped redundantly. Without these flags a
+    // bundle that names a custom alias is broken on import.
     runWorcaTemplates(projectRoot, [
       'export',
       '--to',
@@ -321,6 +327,8 @@ function exportBundle(projectRoot, id, mode = 'standalone') {
       id,
       '--mode',
       normalizedMode,
+      '--include-models',
+      '--include-pricing',
     ]);
     if (existsSync(bundlePath)) {
       const buf = readFileSync(bundlePath);
@@ -354,7 +362,15 @@ function exportBundle(projectRoot, id, mode = 'standalone') {
 function exportGist(projectRoot, id) {
   const stdout = runWorcaTemplates(
     projectRoot,
-    ['export', '--to', 'gist', '--templates', id],
+    [
+      'export',
+      '--to',
+      'gist',
+      '--templates',
+      id,
+      '--include-models',
+      '--include-pricing',
+    ],
     { timeout: 30000 },
   );
   // The CLI prints the gist URL (from `gh gist create`) as its final stdout line.