@volter/supercode-interchange 0.0.0-stage → 0.1.0

package/store-registry.mjs

@@ -0,0 +1,62 @@
+import { readdir, stat } from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+
+const absent = (error) => error.code === 'ENOENT' || error.code === 'ENOTDIR';
+const order = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b));
+
+export async function sourceStat(path) {
+  try { return await stat(path, { bigint: true }); }
+  catch (error) { if (absent(error)) return null; throw error; }
+}
+
+export async function sourceEntries(path) {
+  try { return await readdir(path); }
+  catch (error) { if (absent(error)) return []; throw error; }
+}
+
+async function namesFile(path) {
+  const info = await sourceStat(path);
+  return info ? info.isFile() : extname(path) !== '';
+}
+
+/** Follow a profile symlink, but never turn a refused registry or target into
+ * an empty selection. Dot folders have the same exclusion as native readers. */
+export async function profileDirectories(root) {
+  if (!(await sourceStat(root))?.isDirectory()) return [];
+  const named = [];
+  for (const name of await sourceEntries(join(root, 'profiles'))) {
+    const path = join(root, 'profiles', name);
+    const info = await sourceStat(path);
+    if (info?.isDirectory() && !name.startsWith('.')) named.push({ profile: name, path });
+  }
+  named.sort((a, b) => order(a.profile, b.profile));
+  return [{ profile: 'default', path: root }, ...named];
+}
+
+export async function selectStoreFiles(harness, homes) {
+  const plain = (path) => ({ path, profile: null });
+  if (harness === 'opencode') {
+    if (await namesFile(homes.opencode)) return [plain(homes.opencode)];
+    return (await sourceEntries(homes.opencode)).filter((name) => name.startsWith('opencode') && name.endsWith('.db'))
+      .sort(order).map((name) => plain(join(homes.opencode, name)));
+  }
+  if (harness === 'goose') {
+    if (await namesFile(homes.goose)) return [plain(homes.goose)];
+    const direct = join(homes.goose, 'sessions.db');
+    return [plain((await sourceStat(direct))?.isFile() ? direct : join(homes.goose, 'sessions', 'sessions.db'))];
+  }
+  if (harness === 'hermes') {
+    const root = dirname(homes.hermes), name = basename(homes.hermes);
+    return [plain(homes.hermes), ...(await profileDirectories(root)).slice(1).map(({ path }) => plain(join(path, name)))];
+  }
+  if (harness === 'orchestrator') return (await profileDirectories(homes.orchestrator)).map(({ profile, path }) => ({ profile, path: join(path, 'state.db') }));
+  return [];
+}
+
+export async function storeRegistryDirectories(harness, homes) {
+  if (harness === 'opencode') return [await namesFile(homes.opencode) ? dirname(homes.opencode) : homes.opencode];
+  if (harness === 'goose') return await namesFile(homes.goose) ? [dirname(homes.goose)] : [homes.goose, join(homes.goose, 'sessions')];
+  if (harness === 'hermes') return [join(dirname(homes.hermes), 'profiles'), dirname(homes.hermes)];
+  if (harness === 'orchestrator') return [homes.orchestrator, join(homes.orchestrator, 'profiles')];
+  return [];
+}

package/text.mjs

@@ -0,0 +1,17 @@
+// Rust str::trim uses Unicode White_Space, which differs from JS trim for
+// U+0085 and U+FEFF. Keep source titles/content and query boundaries consistent.
+const leading = /^[\u0009-\u000d\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+/u;
+const trailing = /[\u0009-\u000d\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+$/u;
+export const nativeTrim = (text) => text.replace(leading, '').replace(trailing, '');
+
+export function displayText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return null;
+  return nativeTrim(content.filter((part) => typeof part?.text === 'string').map((part) => part.text).join(' '));
+}
+
+export function truncateScalars(text, count) {
+  let end = 0, used = 0;
+  for (const scalar of text) { if (used++ >= count) break; end += scalar.length; }
+  return text.slice(0, end);
+}

package/workspace.mjs

@@ -0,0 +1,104 @@
+import { statSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+
+const canonical = (path) => { try { return realpathSync.native(path); } catch { return null; } };
+const stat = (path) => { try { return statSync(path); } catch { return null; } };
+
+function comparisonKey(path) {
+  if (process.platform !== 'win32') return path;
+  return path.replace(/^\\\\\?\\UNC\\/, '\\\\').replace(/^\\\\\?\\/, '').toLowerCase();
+}
+
+function keys(path) {
+  const real = canonical(path);
+  return [...new Set([...(real ? [comparisonKey(real)] : []), comparisonKey(resolve(path))])];
+}
+
+function contains(root, path) {
+  const part = relative(root, path);
+  return part === '' || (!isAbsolute(part) && part !== '..' && !part.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`));
+}
+
+/** Exact and subtree workspace semantics from the native catalog. Only
+ * directly linked directories widen a subtree, and never to its ancestor. */
+export function workspaceScope(query) {
+  if (query.workspace == null) return null;
+  const wanted = query.workspace;
+  const subtree = query.workspace_subtree === true;
+  const roots = keys(wanted);
+  if (subtree) {
+    const own = [...roots];
+    let entries = [];
+    try { entries = readdirSync(wanted, { withFileTypes: true }); } catch { /* catalog's soft linked-folder fallback */ }
+    for (const entry of entries) {
+      const path = join(wanted, entry.name);
+      if (!entry.isSymbolicLink() || !stat(path)?.isDirectory()) continue;
+      for (const key of keys(path)) {
+        if (!own.some((root) => contains(key, root)) && !roots.some((root) => contains(root, key))) roots.push(key);
+      }
+    }
+  }
+  const judged = new Map();
+  return (descriptor) => {
+    const recorded = descriptor.cwd;
+    const harness = descriptor.locator.harness;
+    // These two native stores historically compare an exact cwd literally.
+    if (!subtree && (harness === 'hermes' || harness === 'openclaw')) return recorded === wanted;
+    if (typeof recorded !== 'string' || !isAbsolute(recorded)) return false;
+    if (judged.has(recorded)) return judged.get(recorded);
+    let admitted;
+    if (subtree) admitted = keys(recorded).some((key) => roots.some((root) => contains(root, key)));
+    else {
+      const left = canonical(recorded), right = canonical(wanted);
+      admitted = left != null && right != null ? left === right : resolve(recorded) === resolve(wanted);
+    }
+    judged.set(recorded, admitted);
+    return admitted;
+  };
+}
+
+function originUrl(common) {
+  let text;
+  try { text = readFileSync(join(common, 'config'), 'utf8'); } catch { return null; }
+  let inOrigin = false;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith('[')) { inOrigin = line.startsWith('[remote "origin"]'); continue; }
+    if (inOrigin) {
+      const match = /^url\s*=\s*(.+)$/.exec(line);
+      if (match?.[1].trim()) return match[1].trim();
+    }
+  }
+  return null;
+}
+
+/** Read the common-directory/remote family from Git files, without a child
+ * process. A non-repository path only joins that exact path. */
+export function repositoryFamily(path) {
+  const start = canonical(path) ?? path;
+  for (let dir = start;; dir = dirname(dir)) {
+    const dotGit = join(dir, '.git');
+    const kind = stat(dotGit);
+    let common = null;
+    if (kind?.isDirectory()) common = canonical(dotGit) ?? dotGit;
+    else if (kind?.isFile()) {
+      let text = '';
+      try { text = readFileSync(dotGit, 'utf8'); } catch { /* native catalog keeps walking */ }
+      const pointer = text.split(/\r?\n/).map((line) => line.trim()).find((line) => line.startsWith('gitdir:'));
+      if (pointer) {
+        const target = pointer.slice(7).trim();
+        const gitdir = isAbsolute(target) ? target : join(dir, target);
+        const parent = dirname(gitdir);
+        common = basename(parent) === 'worktrees' ? dirname(parent) : gitdir;
+        common = canonical(common) ?? common;
+      }
+    }
+    if (common) return { identity: common, repository: true, origin: originUrl(common) };
+    if (dirname(dir) === dir) break;
+  }
+  return { identity: start, repository: false, origin: null };
+}
+
+export function sameRepositoryFamily(left, right) {
+  return left.identity === right.identity || (left.repository && right.repository && left.origin != null && left.origin === right.origin);
+}