@xelauvas/xela-cli 0.3.1 → 0.4.0

package/src/_shims/bun_bundle.js

@@ -1,8 +1,83 @@
 // Shim for bun:bundle - replaces build-time feature flags with runtime config
-// All features default to false (minimal external build)
-const ENABLED_FEATURES = new Set([
-  // Only enable what's absolutely needed for basic REPL
-]);
+// Only client-side features are enabled. Flags that need Anthropic servers
+// (KAIROS, CCR, BRIDGE, DAEMON, telemetry, server-side context management)
+// stay off. Override with XELA_FEATURES="FLAG_A,FLAG_B" (replaces the list)
+// or XELA_FEATURES_DISABLE="FLAG_A" (removes from the list).
+// Flags whose code the fork lacks are stubbed by the loader; the ones that
+// still need Anthropic servers (KAIROS, CCR, DAEMON, telemetry, CACHED_MICROCOMPACT)
+// stay off. TREE_SITTER_BASH needs web-tree-sitter, CACHED_MICROCOMPACT the
+// Anthropic API.
+const DEFAULT_FEATURES = [
+  // Permissions: auto mode (⏵⏵ Auto via Shift+Tab) runs the classifier on the configured model
+  'TRANSCRIPT_CLASSIFIER',
+  'BASH_CLASSIFIER',
+  // Agents: teams/agents panel, Explore/Plan built-in subagents, fork subagent, verification agent
+  'TEAMMEM',
+  'BUILTIN_EXPLORE_PLAN_AGENTS',
+  'FORK_SUBAGENT',
+  'VERIFICATION_AGENT',
+  'AGENT_MEMORY_SNAPSHOT',
+  // Background sessions and the Monitor tool (reimplemented in tools/MonitorTool)
+  'BG_SESSIONS',
+  'MONITOR_TOOL',
+  // Workflow scripts (reimplemented in tools/WorkflowTool)
+  'WORKFLOW_SCRIPTS',
+  // Context management: snip (model-driven), collapse (background summaries), compact on prompt-too-long
+  'HISTORY_SNIP',
+  'CONTEXT_COLLAPSE',
+  'REACTIVE_COMPACT',
+  'TOKEN_BUDGET',
+  'COMPACTION_REMINDERS',
+  // UI
+  'MESSAGE_ACTIONS',
+  'HISTORY_PICKER',
+  'QUICK_SEARCH',
+  'AUTO_THEME',
+  'HOOK_PROMPTS',
+  // Tools reimplemented here: terminal panel capture (tmux), headless browser (gstack browse), local skill discovery
+  'TERMINAL_PANEL',
+  'WEB_BROWSER_TOOL',
+  'EXPERIMENTAL_SKILL_SEARCH',
+  // Misc
+  'MCP_SKILLS',
+  'NEW_INIT',
+  'ULTRATHINK',
+  // Cross-session messaging (SendMessage to uds:<socket>, /peers, ListPeers)
+  'UDS_INBOX',
+  // Proactive mode (/proactive, Sleep tool, <tick> check-ins)
+  'PROACTIVE',
+  // Skills & tools reimplemented locally
+  'KAIROS_DREAM',            // /dream memory consolidation
+  'KAIROS_PUSH_NOTIFICATION', // PushNotification tool (terminal/OS notification)
+  'KAIROS_GITHUB_WEBHOOKS',  // SubscribePR tool (gh polling through Monitor)
+  'REVIEW_ARTIFACT',         // /hunter + ReviewArtifact tool
+  'RUN_SKILL_GENERATOR',     // /run-skill-generator
+  'BUILDING_CLAUDE_APPS',    // /claude-api skill
+  'AGENT_TRIGGERS',          // CronCreate/CronList/CronDelete + /loop
+  'BUDDY',                   // /buddy companion
+  'TEMPLATES',               // background job state (CLAUDE_JOB_DIR)
+  'AWAY_SUMMARY',
+  'UNATTENDED_RETRY',
+  'DUMP_SYSTEM_PROMPT',
+  'NATIVE_CLIPBOARD_IMAGE',
+  'MCP_RICH_OUTPUT',
+  // Assistant mode (xela-local --assistant, CLAUDE_CODE_ASSISTANT=1 or
+  // .claude/agents/assistant.md) and brief mode (/brief, SendUserMessage tool)
+  'KAIROS',
+  'KAIROS_BRIEF',
+  // Background memory extraction after turns (every 3 turns locally; see
+  // memdir/paths.ts isExtractGateOpen)
+  'EXTRACT_MEMORIES',
+];
+
+const ENABLED_FEATURES = new Set(
+  process.env.XELA_FEATURES
+    ? process.env.XELA_FEATURES.split(',').map(s => s.trim()).filter(Boolean)
+    : DEFAULT_FEATURES,
+);
+for (const f of (process.env.XELA_FEATURES_DISABLE || '').split(',')) {
+  if (f.trim()) ENABLED_FEATURES.delete(f.trim());
+}
 
 export function feature(name) {
   return ENABLED_FEATURES.has(name);

package/src/_shims/cjs_stub.cjs

@@ -1,23 +1,45 @@
-// CJS stub for missing/DCE'd modules
-// Returns safe defaults for any property access
-const noop = () => {};
+// CJS stub for missing/DCE'd modules.
+//
+// Named exports resolve to `undefined`, so feature-gated code written as
+// `feature('X') ? require('./mod.js').Thing : null` degrades to "feature
+// absent" instead of receiving a no-op function that the app then treats as a
+// real tool, task or command (which used to break startup silently).
+// The default export is '' for text-file imports (.txt/.md), and the object is
+// still callable (returns '') for code that invokes the module itself.
+// Stub function by name: predicates stay false, getters/loaders yield nothing,
+// transform-style helpers (project/apply/convert...) pass their input through.
+function stubFunctionFor(name) {
+  if (/^(is|has|should|can|was|needs|allow|supports|uses|matches|includes|contains)[A-Z_]/.test(name)) return () => false;
+  if (/^(get|find|read|load|fetch|resolve|create|build|make|compute|calculate|extract|lookup|select|detect)[A-Z_]/.test(name)) return () => undefined;
+  return (x) => x;
+}
+const noop = (x) => x;
 
-// Make a string-like object that also works as a function
-const stub = new Proxy(noop, {
+function makeStub(spec) {
+  return new Proxy(noop, {
   get(target, prop) {
+    if (prop === '__makeStub') return makeStub;
     if (prop === '__esModule') return true;
-    // .default should return empty string (for text file imports like .txt/.md)
     if (prop === 'default') return '';
     if (prop === 'then') return undefined; // Not a Promise
     if (prop === Symbol.toPrimitive) return () => '';
     if (prop === Symbol.iterator) return undefined;
     if (prop === Symbol.asyncIterator) return undefined;
-    // String methods should work (trimEnd, etc.)
+    // String methods keep working for code that treats the module as text
     if (typeof ''[prop] === 'function') return String.prototype[prop].bind('');
-    // Return a no-op function for any other property
-    return noop;
+    if (process.env.XELA_LOADER_DEBUG) {
+      process.stderr.write(`[require] STUB property ${String(prop)} requested from missing module ${spec}\n`);
+    }
+    // PascalCase names are classes, tools, tasks, components: `undefined` lets
+    // `feature('X') ? require(m).Thing : null` skip them. camelCase names are
+    // functions: an inert no-op keeps `isFooEnabled()`-style checks falsy.
+    if (typeof prop === 'string' && /^[A-Z]/.test(prop)) return undefined;
+    return typeof prop === 'string' ? stubFunctionFor(prop) : noop;
   },
   apply() { return ''; },
-});
+  });
+}
 
+const stub = makeStub('(unknown)');
 module.exports = stub;
+module.exports.__makeStub = makeStub;

package/src/_shims/loader.js

@@ -231,8 +231,83 @@ try { writeFileSync(UNIVERSAL_STUB_PATH, UNIVERSAL_STUB_SOURCE); } catch {}
 const UNIVERSAL_STUB_URL = pathToFileURL(UNIVERSAL_STUB_PATH).href;
 stubUrls.add(UNIVERSAL_STUB_URL);
 
-function generateStubUrl(_specifier) {
-  return UNIVERSAL_STUB_URL;
+// XELA_LOADER_DEBUG=1 lists every import that resolved to a stub (missing module)
+const LOADER_DEBUG = !!process.env.XELA_LOADER_DEBUG;
+
+// Stub value heuristics, by export name:
+//   PascalCase (classes, tools, components, tasks) -> undefined, so
+//     `feature('X') ? mod.Thing : null` style code skips the feature;
+//   UPPER_SNAKE constants -> [] when plural-looking, '' otherwise, so
+//     `.length`, spreads and string ops keep working;
+//   camelCase functions -> a no-op returning undefined.
+function stubValueFor(name) {
+  if (/^[A-Z][A-Z0-9_]*$/.test(name)) {
+    return /(S|LIST|TOOLS|KEYS|NAMES|PATHS|TYPES|FLAGS)$/.test(name) ? '[]' : "''";
+  }
+  if (/^[A-Z]/.test(name)) return 'undefined';
+  // predicates stay false, getters/loaders yield nothing, transform-style
+  // helpers (projectView(messages), applyX(messages)) pass their input through
+  if (/^(is|has|should|can|was|needs|allow|supports|uses|matches|includes|contains)[A-Z_]/.test(name)) return '() => false';
+  if (/^(get|find|read|load|fetch|resolve|create|build|make|compute|calculate|extract|lookup|select|detect)[A-Z_]/.test(name)) return '() => undefined';
+  return '(x) => x';
+}
+
+// Build a stub tailored to what the importing file actually imports from the
+// missing specifier. A universal stub cannot know every export name, and an
+// ESM import of a name the stub lacks is a link-time error.
+function collectImportedNames(parentSource, specifier) {
+  const names = new Set();
+  let hasDefault = false;
+  let hasNamespace = false;
+  const esc = specifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(
+    `import\\s+(?:type\\s+)?([^;'"]*?)\\s+from\\s+['"]${esc}['"]|export\\s+(?:type\\s+)?(\\{[^}]*\\})\\s+from\\s+['"]${esc}['"]`,
+    'g',
+  );
+  let m;
+  while ((m = re.exec(parentSource)) !== null) {
+    const clause = (m[1] ?? m[2] ?? '').trim();
+    if (!clause) continue;
+    if (clause.startsWith('*')) { hasNamespace = true; continue; }
+    const braces = clause.match(/\{([^}]*)\}/);
+    const before = clause.replace(/\{[^}]*\}/, '').replace(/,/g, '').trim();
+    if (before && !before.startsWith('type ')) hasDefault = true;
+    if (braces) {
+      for (const part of braces[1].split(',')) {
+        const p = part.trim().replace(/^type\s+/, '');
+        if (!p) continue;
+        const asMatch = p.match(/^(\S+)\s+as\s+(\S+)$/);
+        const exported = asMatch ? asMatch[1] : p;
+        if (exported === 'default') { hasDefault = true; continue; }
+        names.add(exported);
+      }
+    }
+  }
+  return { names: [...names], hasDefault, hasNamespace };
+}
+
+function generateStubUrl(specifier, parentURL) {
+  const parent = parentURL ? fileURLToPath(parentURL) : null;
+  if (LOADER_DEBUG) {
+    process.stderr.write(`[loader] STUB ${specifier}  <- ${parent ? parent.replace(SRC_ROOT + '/', '') : '?'}\n`);
+  }
+  if (!parent) return UNIVERSAL_STUB_URL;
+  let source = '';
+  try { source = readFileSync(parent, 'utf-8'); } catch { return UNIVERSAL_STUB_URL; }
+  const { names, hasDefault } = collectImportedNames(source, specifier);
+  if (LOADER_DEBUG) process.stderr.write(`[loader]   names for ${specifier}: ${names.join(',') || '(none)'} default=${hasDefault}\n`);
+  if (names.length === 0 && !hasDefault) return UNIVERSAL_STUB_URL;
+  const lines = [`// Generated stub for missing module ${specifier} (imported by ${parent.replace(SRC_ROOT + '/', '')})`];
+  for (const name of names) lines.push(`export const ${name} = ${stubValueFor(name)};`);
+  lines.push(`export default ${hasDefault ? "''" : '{}'};`);
+  const key = createHash('md5').update(specifier + '|' + names.sort().join(',') + '|' + hasDefault).digest('hex');
+  const stubPath = join(STUB_DIR, `stub_${key}.mjs`);
+  if (!isFile(stubPath)) {
+    try { writeFileSync(stubPath, lines.join('\n') + '\n'); } catch { return UNIVERSAL_STUB_URL; }
+  }
+  const url = pathToFileURL(stubPath).href;
+  stubUrls.add(url);
+  return url;
 }
 
 export async function resolve(specifier, context, nextResolve) {
@@ -248,7 +323,7 @@ export async function resolve(specifier, context, nextResolve) {
     if (resolved) {
       return { url: pathToFileURL(resolved).href, shortCircuit: true };
     }
-    const stubUrl = generateStubUrl(specifier);
+    const stubUrl = generateStubUrl(specifier, context.parentURL);
     return { url: stubUrl, shortCircuit: true };
   }
 
@@ -269,7 +344,7 @@ export async function resolve(specifier, context, nextResolve) {
       return { url: pathToFileURL(textStubPath).href, shortCircuit: true };
     }
     // Extract the basename for stub generation
-    const stubUrl = generateStubUrl(specifier.split('/').pop().replace(/\.\w+$/, ''));
+    const stubUrl = generateStubUrl(specifier, context.parentURL);
     return { url: stubUrl, shortCircuit: true };
   }
 
@@ -278,7 +353,7 @@ export async function resolve(specifier, context, nextResolve) {
     const result = await nextResolve(specifier, context);
     return result;
   } catch (err) {
-    const stubUrl = generateStubUrl(specifier.split('/').pop() || specifier);
+    const stubUrl = generateStubUrl(specifier, context.parentURL);
     return { url: stubUrl, shortCircuit: true };
   }
 }
@@ -314,6 +389,30 @@ export function load(url, context, nextLoad) {
         sourcefile: filePath,
       }));
 
+      // Dynamic import() of a module that does not exist (feature-gated code
+      // that was stripped): resolve to a proxy whose camelCase members are
+      // pass-through functions and PascalCase members are undefined, instead
+      // of a stub that cannot know which names the caller will read.
+      code = code.replace(/\bimport\((['"])((?:\.|src\/)[^'"]+)\1\)/g, (full, q, spec) => {
+        const base = spec.startsWith('src/') ? join(SRC_ROOT, spec.slice(4)) : pathResolve(dirname(filePath), spec);
+        if (tryResolveFile(base)) return full;
+        if (LOADER_DEBUG) process.stderr.write(`[loader] DYNAMIC STUB ${spec}  <- ${filePath.replace(SRC_ROOT + '/', '')}\n`);
+        return `Promise.resolve(globalThis.__xelaMissingModule(${JSON.stringify(spec)}))`;
+      });
+      if (code.includes('__xelaMissingModule(')) {
+        code = `globalThis.__xelaMissingModule ??= (spec) => new Proxy({}, { get(_t, prop) {
+  if (prop === 'then') return undefined;
+  if (prop === 'default') return '';
+  if (typeof prop !== 'string') return undefined;
+  if (/^[A-Z][A-Z0-9_]*$/.test(prop)) return /(S|LIST|TOOLS|KEYS|NAMES|PATHS|TYPES|FLAGS)$/.test(prop) ? [] : '';
+  if (/^[A-Z]/.test(prop)) return undefined;
+  if (/^(is|has|should|can|was|needs|allow|supports|uses|matches|includes|contains)[A-Z_]/.test(prop)) return () => false;
+  if (/^(get|find|read|load|fetch|resolve|create|build|make|compute|calculate|extract|lookup|select|detect)[A-Z_]/.test(prop)) return () => undefined;
+  return (x) => x;
+} });
+` + code;
+      }
+
       // If the compiled code still has require() calls, inject a CJS-compatible require
       // that resolves relative to this file's directory
       if (code.includes('require(') || code.includes('require.resolve(')) {