shortcutxl 0.2.0

package/agent-docs/examples/extensions/doom-overlay/doom-component.ts

@@ -0,0 +1,133 @@
+/**
+ * DOOM Component for overlay mode
+ *
+ * Renders DOOM frames using half-block characters (▀) with 24-bit color.
+ * Height is calculated from width to maintain DOOM's aspect ratio.
+ */
+
+import type { Component } from 'shortcutxl';
+import { isKeyRelease, type TUI } from 'shortcutxl';
+import type { DoomEngine } from './doom-engine.js';
+import { DoomKeys, mapKeyToDoom } from './doom-keys.js';
+
+function renderHalfBlock(
+  rgba: Uint8Array,
+  width: number,
+  height: number,
+  targetCols: number,
+  targetRows: number
+): string[] {
+  const lines: string[] = [];
+  const scaleX = width / targetCols;
+  const scaleY = height / (targetRows * 2);
+
+  for (let row = 0; row < targetRows; row++) {
+    let line = '';
+    const srcY1 = Math.floor(row * 2 * scaleY);
+    const srcY2 = Math.floor((row * 2 + 1) * scaleY);
+
+    for (let col = 0; col < targetCols; col++) {
+      const srcX = Math.floor(col * scaleX);
+      const idx1 = (srcY1 * width + srcX) * 4;
+      const idx2 = (srcY2 * width + srcX) * 4;
+      const r1 = rgba[idx1] ?? 0,
+        g1 = rgba[idx1 + 1] ?? 0,
+        b1 = rgba[idx1 + 2] ?? 0;
+      const r2 = rgba[idx2] ?? 0,
+        g2 = rgba[idx2 + 1] ?? 0,
+        b2 = rgba[idx2 + 2] ?? 0;
+      line += `\x1b[38;2;${r1};${g1};${b1}m\x1b[48;2;${r2};${g2};${b2}m▀`;
+    }
+    line += '\x1b[0m';
+    lines.push(line);
+  }
+  return lines;
+}
+
+export class DoomOverlayComponent implements Component {
+  private engine: DoomEngine;
+  private tui: TUI;
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private onExit: () => void;
+
+  // Opt-in to key release events for smooth movement
+  wantsKeyRelease = true;
+
+  constructor(tui: TUI, engine: DoomEngine, onExit: () => void, resume = false) {
+    this.tui = tui;
+    this.engine = engine;
+    this.onExit = onExit;
+
+    // Unpause if resuming
+    if (resume) {
+      this.engine.pushKey(true, DoomKeys.KEY_PAUSE);
+      this.engine.pushKey(false, DoomKeys.KEY_PAUSE);
+    }
+
+    this.startGameLoop();
+  }
+
+  private startGameLoop(): void {
+    this.interval = setInterval(() => {
+      try {
+        this.engine.tick();
+        this.tui.requestRender();
+      } catch {
+        // WASM error (e.g., exit via DOOM menu) - treat as quit
+        this.dispose();
+        this.onExit();
+      }
+    }, 1000 / 35);
+  }
+
+  handleInput(data: string): void {
+    // Q to pause and exit (but not on release)
+    if (!isKeyRelease(data) && (data === 'q' || data === 'Q')) {
+      // Send DOOM's pause key before exiting
+      this.engine.pushKey(true, DoomKeys.KEY_PAUSE);
+      this.engine.pushKey(false, DoomKeys.KEY_PAUSE);
+      this.dispose();
+      this.onExit();
+      return;
+    }
+
+    const doomKeys = mapKeyToDoom(data);
+    if (doomKeys.length === 0) return;
+
+    const released = isKeyRelease(data);
+
+    for (const key of doomKeys) {
+      this.engine.pushKey(!released, key);
+    }
+  }
+
+  render(width: number): string[] {
+    // DOOM renders at 640x400 (1.6:1 ratio)
+    // With half-block characters, each terminal row = 2 pixels
+    // So effective ratio is 640:200 = 3.2:1 (width:height in terminal cells)
+    // Add 1 row for footer
+    const ASPECT_RATIO = 3.2;
+    const MIN_HEIGHT = 10;
+    const height = Math.max(MIN_HEIGHT, Math.floor(width / ASPECT_RATIO));
+
+    const rgba = this.engine.getFrameRGBA();
+    const lines = renderHalfBlock(rgba, this.engine.width, this.engine.height, width, height);
+
+    // Footer
+    const footer =
+      ' DOOM | Q=Pause | WASD=Move | Shift+WASD=Run | Space=Use | F=Fire | 1-7=Weapons';
+    const truncatedFooter = footer.length > width ? footer.slice(0, width) : footer;
+    lines.push(`\x1b[2m${truncatedFooter}\x1b[0m`);
+
+    return lines;
+  }
+
+  invalidate(): void {}
+
+  dispose(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+}

package/agent-docs/examples/extensions/doom-overlay/doom-engine.ts

@@ -0,0 +1,186 @@
+/**
+ * DOOM Engine - WebAssembly wrapper for doomgeneric
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export interface DoomModule {
+  _doomgeneric_Create: (argc: number, argv: number) => void;
+  _doomgeneric_Tick: () => void;
+  _DG_GetFrameBuffer: () => number;
+  _DG_GetScreenWidth: () => number;
+  _DG_GetScreenHeight: () => number;
+  _DG_PushKeyEvent: (pressed: number, key: number) => void;
+  _malloc: (size: number) => number;
+  _free: (ptr: number) => void;
+  HEAPU8: Uint8Array;
+  HEAPU32: Uint32Array;
+  FS_createDataFile: (
+    parent: string,
+    name: string,
+    data: number[],
+    canRead: boolean,
+    canWrite: boolean
+  ) => void;
+  FS_createPath: (parent: string, path: string, canRead: boolean, canWrite: boolean) => string;
+  setValue: (ptr: number, value: number, type: string) => void;
+  getValue: (ptr: number, type: string) => number;
+}
+
+export class DoomEngine {
+  private module: DoomModule | null = null;
+  private frameBufferPtr: number = 0;
+  private initialized = false;
+  private wadPath: string;
+  private _width = 640;
+  private _height = 400;
+
+  constructor(wadPath: string) {
+    this.wadPath = wadPath;
+  }
+
+  get width(): number {
+    return this._width;
+  }
+
+  get height(): number {
+    return this._height;
+  }
+
+  async init(): Promise<void> {
+    // Locate WASM build
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const buildDir = join(__dirname, 'doom', 'build');
+    const doomJsPath = join(buildDir, 'doom.js');
+
+    if (!existsSync(doomJsPath)) {
+      throw new Error(`WASM not found at ${doomJsPath}. Run ./doom/build.sh first`);
+    }
+
+    // Read WAD file
+    const wadData = readFileSync(this.wadPath);
+    const wadArray = Array.from(new Uint8Array(wadData));
+
+    // Load WASM module - eval to bypass jiti completely
+    const doomJsCode = readFileSync(doomJsPath, 'utf-8');
+    const moduleExports: { exports: unknown } = { exports: {} };
+    const nativeRequire = createRequire(doomJsPath);
+    const moduleFunc = new Function(
+      'module',
+      'exports',
+      '__dirname',
+      '__filename',
+      'require',
+      doomJsCode
+    );
+    moduleFunc(moduleExports, moduleExports.exports, buildDir, doomJsPath, nativeRequire);
+    const createDoomModule = moduleExports.exports as (config: unknown) => Promise<DoomModule>;
+
+    const moduleConfig = {
+      locateFile: (path: string) => {
+        if (path.endsWith('.wasm')) {
+          return join(buildDir, path);
+        }
+        return path;
+      },
+      print: () => {},
+      printErr: () => {},
+      preRun: [
+        (module: DoomModule) => {
+          // Create /doom directory and add WAD
+          module.FS_createPath('/', 'doom', true, true);
+          module.FS_createDataFile('/doom', 'doom1.wad', wadArray, true, false);
+        }
+      ]
+    };
+
+    this.module = await createDoomModule(moduleConfig);
+    if (!this.module) {
+      throw new Error('Failed to initialize DOOM module');
+    }
+
+    // Initialize DOOM
+    this.initDoom();
+
+    // Get framebuffer info
+    this.frameBufferPtr = this.module._DG_GetFrameBuffer();
+    this._width = this.module._DG_GetScreenWidth();
+    this._height = this.module._DG_GetScreenHeight();
+    this.initialized = true;
+  }
+
+  private initDoom(): void {
+    if (!this.module) return;
+
+    const args = ['doom', '-iwad', '/doom/doom1.wad'];
+    const argPtrs: number[] = [];
+
+    for (const arg of args) {
+      const ptr = this.module._malloc(arg.length + 1);
+      for (let i = 0; i < arg.length; i++) {
+        this.module.setValue(ptr + i, arg.charCodeAt(i), 'i8');
+      }
+      this.module.setValue(ptr + arg.length, 0, 'i8');
+      argPtrs.push(ptr);
+    }
+
+    const argvPtr = this.module._malloc(argPtrs.length * 4);
+    for (let i = 0; i < argPtrs.length; i++) {
+      this.module.setValue(argvPtr + i * 4, argPtrs[i]!, 'i32');
+    }
+
+    this.module._doomgeneric_Create(args.length, argvPtr);
+
+    for (const ptr of argPtrs) {
+      this.module._free(ptr);
+    }
+    this.module._free(argvPtr);
+  }
+
+  /**
+   * Run one game tick
+   */
+  tick(): void {
+    if (!this.module || !this.initialized) return;
+    this.module._doomgeneric_Tick();
+  }
+
+  /**
+   * Get current frame as RGBA pixel data
+   * DOOM outputs ARGB, we convert to RGBA
+   */
+  getFrameRGBA(): Uint8Array {
+    if (!this.module || !this.initialized) {
+      return new Uint8Array(this._width * this._height * 4);
+    }
+
+    const pixels = this._width * this._height;
+    const buffer = new Uint8Array(pixels * 4);
+
+    for (let i = 0; i < pixels; i++) {
+      const argb = this.module.getValue(this.frameBufferPtr + i * 4, 'i32');
+      const offset = i * 4;
+      buffer[offset + 0] = (argb >> 16) & 0xff; // R
+      buffer[offset + 1] = (argb >> 8) & 0xff; // G
+      buffer[offset + 2] = argb & 0xff; // B
+      buffer[offset + 3] = 255; // A
+    }
+
+    return buffer;
+  }
+
+  /**
+   * Push a key event
+   */
+  pushKey(pressed: boolean, key: number): void {
+    if (!this.module || !this.initialized) return;
+    this.module._DG_PushKeyEvent(pressed ? 1 : 0, key);
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+}

package/agent-docs/examples/extensions/doom-overlay/doom-keys.ts

@@ -0,0 +1,108 @@
+/**
+ * DOOM key codes (from doomkeys.h)
+ */
+export const DoomKeys = {
+  KEY_RIGHTARROW: 0xae,
+  KEY_LEFTARROW: 0xac,
+  KEY_UPARROW: 0xad,
+  KEY_DOWNARROW: 0xaf,
+  KEY_STRAFE_L: 0xa0,
+  KEY_STRAFE_R: 0xa1,
+  KEY_USE: 0xa2,
+  KEY_FIRE: 0xa3,
+  KEY_ESCAPE: 27,
+  KEY_ENTER: 13,
+  KEY_TAB: 9,
+  KEY_F1: 0x80 + 0x3b,
+  KEY_F2: 0x80 + 0x3c,
+  KEY_F3: 0x80 + 0x3d,
+  KEY_F4: 0x80 + 0x3e,
+  KEY_F5: 0x80 + 0x3f,
+  KEY_F6: 0x80 + 0x40,
+  KEY_F7: 0x80 + 0x41,
+  KEY_F8: 0x80 + 0x42,
+  KEY_F9: 0x80 + 0x43,
+  KEY_F10: 0x80 + 0x44,
+  KEY_F11: 0x80 + 0x57,
+  KEY_F12: 0x80 + 0x58,
+  KEY_BACKSPACE: 127,
+  KEY_PAUSE: 0xff,
+  KEY_EQUALS: 0x3d,
+  KEY_MINUS: 0x2d,
+  KEY_RSHIFT: 0x80 + 0x36,
+  KEY_RCTRL: 0x80 + 0x1d,
+  KEY_RALT: 0x80 + 0x38
+} as const;
+
+import { Key, matchesKey, parseKey } from 'shortcutxl';
+
+/**
+ * Map terminal key input to DOOM key codes
+ * Supports both raw terminal input and Kitty protocol sequences
+ */
+export function mapKeyToDoom(data: string): number[] {
+  // Arrow keys
+  if (matchesKey(data, Key.up)) return [DoomKeys.KEY_UPARROW];
+  if (matchesKey(data, Key.down)) return [DoomKeys.KEY_DOWNARROW];
+  if (matchesKey(data, Key.right)) return [DoomKeys.KEY_RIGHTARROW];
+  if (matchesKey(data, Key.left)) return [DoomKeys.KEY_LEFTARROW];
+
+  // WASD - check both raw char and Kitty sequences
+  if (data === 'w' || matchesKey(data, 'w')) return [DoomKeys.KEY_UPARROW];
+  if (data === 'W' || matchesKey(data, Key.shift('w')))
+    return [DoomKeys.KEY_UPARROW, DoomKeys.KEY_RSHIFT];
+  if (data === 's' || matchesKey(data, 's')) return [DoomKeys.KEY_DOWNARROW];
+  if (data === 'S' || matchesKey(data, Key.shift('s')))
+    return [DoomKeys.KEY_DOWNARROW, DoomKeys.KEY_RSHIFT];
+  if (data === 'a' || matchesKey(data, 'a')) return [DoomKeys.KEY_STRAFE_L];
+  if (data === 'A' || matchesKey(data, Key.shift('a')))
+    return [DoomKeys.KEY_STRAFE_L, DoomKeys.KEY_RSHIFT];
+  if (data === 'd' || matchesKey(data, 'd')) return [DoomKeys.KEY_STRAFE_R];
+  if (data === 'D' || matchesKey(data, Key.shift('d')))
+    return [DoomKeys.KEY_STRAFE_R, DoomKeys.KEY_RSHIFT];
+
+  // Fire - F key
+  if (data === 'f' || data === 'F' || matchesKey(data, 'f') || matchesKey(data, Key.shift('f'))) {
+    return [DoomKeys.KEY_FIRE];
+  }
+
+  // Use/Open
+  if (data === ' ' || matchesKey(data, Key.space)) return [DoomKeys.KEY_USE];
+
+  // Menu/UI keys
+  if (matchesKey(data, Key.enter)) return [DoomKeys.KEY_ENTER];
+  if (matchesKey(data, Key.escape)) return [DoomKeys.KEY_ESCAPE];
+  if (matchesKey(data, Key.tab)) return [DoomKeys.KEY_TAB];
+  if (matchesKey(data, Key.backspace)) return [DoomKeys.KEY_BACKSPACE];
+
+  // Ctrl keys (except Ctrl+C) = fire (legacy support)
+  const parsed = parseKey(data);
+  if (parsed?.startsWith('ctrl+') && parsed !== 'ctrl+c') {
+    return [DoomKeys.KEY_FIRE];
+  }
+  if (data.length === 1 && data.charCodeAt(0) < 32 && data !== '\x03') {
+    return [DoomKeys.KEY_FIRE];
+  }
+
+  // Weapon selection (0-9)
+  if (data >= '0' && data <= '9') return [data.charCodeAt(0)];
+
+  // Plus/minus for screen size
+  if (data === '+' || data === '=') return [DoomKeys.KEY_EQUALS];
+  if (data === '-') return [DoomKeys.KEY_MINUS];
+
+  // Y/N for prompts
+  if (data === 'y' || data === 'Y' || matchesKey(data, 'y') || matchesKey(data, Key.shift('y'))) {
+    return ['y'.charCodeAt(0)];
+  }
+  if (data === 'n' || data === 'N' || matchesKey(data, 'n') || matchesKey(data, Key.shift('n'))) {
+    return ['n'.charCodeAt(0)];
+  }
+
+  // Other printable characters (for cheats)
+  if (data.length === 1 && data.charCodeAt(0) >= 32) {
+    return [data.toLowerCase().charCodeAt(0)];
+  }
+
+  return [];
+}

package/agent-docs/examples/extensions/doom-overlay/index.ts

@@ -0,0 +1,74 @@
+/**
+ * DOOM Overlay Demo - Play DOOM as an overlay
+ *
+ * Usage: shortcut --extension ./examples/extensions/doom-overlay
+ *
+ * Commands:
+ *   /doom-overlay - Play DOOM in an overlay (Q to pause/exit)
+ *
+ * This demonstrates that overlays can handle real-time game rendering at 35 FPS.
+ */
+
+import type { ExtensionAPI } from 'shortcutxl';
+import { DoomOverlayComponent } from './doom-component.js';
+import { DoomEngine } from './doom-engine.js';
+import { ensureWadFile } from './wad-finder.js';
+
+// Persistent engine instance - survives between invocations
+let activeEngine: DoomEngine | null = null;
+let activeWadPath: string | null = null;
+
+export default function (shortcut: ExtensionAPI) {
+  shortcut.registerCommand('doom-overlay', {
+    description: 'Play DOOM as an overlay. Q to pause and exit.',
+
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify('DOOM requires interactive mode', 'error');
+        return;
+      }
+
+      // Auto-download WAD if not present
+      ctx.ui.notify('Loading DOOM...', 'info');
+      const wad = args?.trim() ? args.trim() : await ensureWadFile();
+
+      if (!wad) {
+        ctx.ui.notify('Failed to download DOOM WAD file. Check your internet connection.', 'error');
+        return;
+      }
+
+      try {
+        // Reuse existing engine if same WAD, otherwise create new
+        let isResume = false;
+        if (activeEngine && activeWadPath === wad) {
+          ctx.ui.notify('Resuming DOOM...', 'info');
+          isResume = true;
+        } else {
+          ctx.ui.notify(`Loading DOOM from ${wad}...`, 'info');
+          activeEngine = new DoomEngine(wad);
+          await activeEngine.init();
+          activeWadPath = wad;
+        }
+
+        await ctx.ui.custom(
+          (tui, _theme, _keybindings, done) => {
+            return new DoomOverlayComponent(tui, activeEngine!, () => done(undefined), isResume);
+          },
+          {
+            overlay: true,
+            overlayOptions: {
+              width: '75%',
+              maxHeight: '95%',
+              anchor: 'center',
+              margin: { top: 1 }
+            }
+          }
+        );
+      } catch (error) {
+        ctx.ui.notify(`Failed to load DOOM: ${error}`, 'error');
+        activeEngine = null;
+        activeWadPath = null;
+      }
+    }
+  });
+}

package/agent-docs/examples/extensions/doom-overlay/wad-finder.ts

@@ -0,0 +1,51 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Get the bundled WAD path (relative to this module)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_WAD = join(__dirname, 'doom1.wad');
+const WAD_URL = 'https://distro.ibiblio.org/slitaz/sources/packages/d/doom1.wad';
+
+const DEFAULT_WAD_PATHS = ['./doom1.wad', './DOOM1.WAD', '~/doom1.wad', '~/.doom/doom1.wad'];
+
+export function findWadFile(customPath?: string): string | null {
+  if (customPath) {
+    const resolved = resolve(customPath.replace(/^~/, process.env.HOME || ''));
+    if (existsSync(resolved)) return resolved;
+    return null;
+  }
+
+  // Check bundled WAD first
+  if (existsSync(BUNDLED_WAD)) {
+    return BUNDLED_WAD;
+  }
+
+  // Fall back to default paths
+  for (const p of DEFAULT_WAD_PATHS) {
+    const resolved = resolve(p.replace(/^~/, process.env.HOME || ''));
+    if (existsSync(resolved)) return resolved;
+  }
+
+  return null;
+}
+
+/** Download the shareware WAD if not present. Returns path or null on failure. */
+export async function ensureWadFile(): Promise<string | null> {
+  // Check if already exists
+  const existing = findWadFile();
+  if (existing) return existing;
+
+  // Download to bundled location
+  try {
+    const response = await fetch(WAD_URL);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    writeFileSync(BUNDLED_WAD, Buffer.from(buffer));
+    return BUNDLED_WAD;
+  } catch {
+    return null;
+  }
+}

package/agent-docs/examples/extensions/dynamic-resources/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: dynamic-resources
+description: Example skill loaded from resources_discover
+---
+
+# Dynamic Resources Skill
+
+This skill is provided by the dynamic-resources extension.

package/agent-docs/examples/extensions/dynamic-resources/dynamic.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "dynamic-resources",
+  "vars": {
+    "cyan": "#00d7ff",
+    "blue": "#5f87ff",
+    "green": "#b5bd68",
+    "red": "#cc6666",
+    "yellow": "#ffff00",
+    "gray": "#808080",
+    "dimGray": "#666666",
+    "darkGray": "#505050",
+    "accent": "#8abeb7",
+    "selectedBg": "#3a3a4a",
+    "userMsgBg": "#343541",
+    "toolPendingBg": "#282832",
+    "toolSuccessBg": "#283228",
+    "toolErrorBg": "#3c2828",
+    "customMsgBg": "#2d2838"
+  },
+  "colors": {
+    "accent": "accent",
+    "border": "blue",
+    "borderAccent": "cyan",
+    "borderMuted": "darkGray",
+    "success": "green",
+    "error": "red",
+    "warning": "yellow",
+    "muted": "gray",
+    "dim": "dimGray",
+    "text": "",
+    "thinkingText": "gray",
+    "selectedBg": "selectedBg",
+    "userMessageBg": "userMsgBg",
+    "userMessageText": "",
+    "customMessageBg": "customMsgBg",
+    "customMessageText": "",
+    "customMessageLabel": "#9575cd",
+    "toolPendingBg": "toolPendingBg",
+    "toolSuccessBg": "toolSuccessBg",
+    "toolErrorBg": "toolErrorBg",
+    "toolTitle": "",
+    "toolOutput": "gray",
+    "mdHeading": "#f0c674",
+    "mdLink": "#81a2be",
+    "mdLinkUrl": "dimGray",
+    "mdCode": "accent",
+    "mdCodeBlock": "green",
+    "mdCodeBlockBorder": "gray",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "gray",
+    "mdHr": "gray",
+    "mdListBullet": "accent",
+    "toolDiffAdded": "green",
+    "toolDiffRemoved": "red",
+    "toolDiffContext": "gray",
+    "syntaxComment": "#6A9955",
+    "syntaxKeyword": "#569CD6",
+    "syntaxFunction": "#DCDCAA",
+    "syntaxVariable": "#9CDCFE",
+    "syntaxString": "#CE9178",
+    "syntaxNumber": "#B5CEA8",
+    "syntaxType": "#4EC9B0",
+    "syntaxOperator": "#D4D4D4",
+    "syntaxPunctuation": "#D4D4D4",
+    "thinkingOff": "darkGray",
+    "thinkingMinimal": "#6e6e6e",
+    "thinkingLow": "#5f87af",
+    "thinkingMedium": "#81a2be",
+    "thinkingHigh": "#b294bb",
+    "thinkingXhigh": "#d183e8",
+    "bashMode": "green"
+  },
+  "export": {
+    "pageBg": "#18181e",
+    "cardBg": "#1e1e24",
+    "infoBg": "#3c3728"
+  }
+}

package/agent-docs/examples/extensions/dynamic-resources/dynamic.md

@@ -0,0 +1,5 @@
+---
+description: Example prompt template loaded from resources_discover
+---
+
+Summarize the current repository structure and mention any build or test commands.

package/agent-docs/examples/extensions/dynamic-resources/index.ts

@@ -0,0 +1,15 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ExtensionAPI } from 'shortcutxl';
+
+const baseDir = dirname(fileURLToPath(import.meta.url));
+
+export default function (shortcut: ExtensionAPI) {
+  shortcut.on('resources_discover', () => {
+    return {
+      skillPaths: [join(baseDir, 'SKILL.md')],
+      promptPaths: [join(baseDir, 'dynamic.md')],
+      themePaths: [join(baseDir, 'dynamic.json')]
+    };
+  });
+}