Skip to content

nanocoai/nanoclaw / .claude/skills/migrate-from-openclaw

migrate-from-openclaw

Verified

Migrate from OpenClaw to NanoClaw v2. Detects an existing OpenClaw installation, extracts identity, channel credentials, scheduled tasks, and other config, then guides interactive migration. Triggers on "migrate from openclaw", "openclaw migration", "import from openclaw".

FileKindSize
MIGRATE_CRONS.mdmarkdown6.1 KB
REMOVE.mdmarkdown2.9 KB
SKILL.mdskill md24.3 KB
scripts/discover-openclaw.tsscript23.1 KB
scripts/extract-channel-credentials.tsscript9.9 KB
scripts/transform.test.tsscript6.9 KB
scripts/transform.tsscript10.8 KB

scripts/discover-openclaw.ts

View on GitHub
/**
 * Discover an existing OpenClaw installation and emit a structured summary.
 *
 * Usage: pnpm exec tsx .claude/skills/migrate-from-openclaw/scripts/discover-openclaw.ts [--state-dir <path>]
 *
 * Checks (in order): --state-dir arg, $OPENCLAW_STATE_DIR, ~/.openclaw, ~/.clawdbot
 * Parses openclaw.json (JSON5-tolerant), scans workspace for identity/memory files,
 * checks cron jobs, MCP servers, and channel credentials.
 *
 * Emits a status block on stdout:
 *   === NANOCLAW MIGRATE: DISCOVERY ===
 *   ...
 *   === END ===
 */

import fs from 'fs';
import os from 'os';
import path from 'path';

// ---------------------------------------------------------------------------
// JSON5-tolerant parser (no dependency)
// ---------------------------------------------------------------------------

function parseJson5(text: string): unknown {
  // Strip single-line comments (// ...) that aren't inside strings
  let cleaned = text.replace(
    /("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g,
    (match, str) => (str ? str : ''),
  );
  // Strip block comments (/* ... */)
  cleaned = cleaned.replace(
    /("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\//g,
    (match, str) => (str ? str : ''),
  );
  // Strip trailing commas before } or ]
  cleaned = cleaned.replace(/,\s*([}\]])/g, '$1');
  return JSON.parse(cleaned);
}

// ---------------------------------------------------------------------------
// Status block emitter (mirrors setup/status.ts convention)
// ---------------------------------------------------------------------------

function emitStatus(fields: Record<string, string | number | boolean>): void {
  const lines = ['=== NANOCLAW MIGRATE: DISCOVERY ==='];
  for (const [key, value] of Object.entries(fields)) {
    lines.push(`${key}: ${value}`);
  }
  lines.push('=== END ===');
  console.log(lines.join('\n'));
}

// ---------------------------------------------------------------------------
// CLI arg parsing
// ---------------------------------------------------------------------------

function parseArgs(): { stateDir?: string } {
  const args = process.argv.slice(2);
  for (let i = 0; i < args.length; i++) {
    if (args[i] === '--state-dir' && args[i + 1]) {
      return { stateDir: args[i + 1] };
    }
  }
  return {};
}

// ---------------------------------------------------------------------------
// Path resolution
// ---------------------------------------------------------------------------

function resolveStateDir(explicit?: string): string | null {
  const home = os.homedir();
  const candidates: string[] = [];

  if (explicit) {
    // Expand ~ prefix
    const expanded = explicit.startsWith('~')
      ? path.join(home, explicit.slice(1))
      : explicit;
    candidates.push(expanded);
  }

  if (process.env.OPENCLAW_STATE_DIR) {
    candidates.push(process.env.OPENCLAW_STATE_DIR);
  }

  candidates.push(path.join(home, '.openclaw'));
  candidates.push(path.join(home, '.clawdbot'));

  for (const dir of candidates) {
    if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
      return dir;
    }
  }
  return null;
}

// ---------------------------------------------------------------------------
// Config loading
// ---------------------------------------------------------------------------

function loadConfig(
  stateDir: string,
): Record<string, unknown> | null {
  for (const name of ['openclaw.json', 'clawdbot.json']) {
    const configPath = path.join(stateDir, name);
    if (fs.existsSync(configPath)) {
      try {
        const raw = fs.readFileSync(configPath, 'utf-8');
        return parseJson5(raw) as Record<string, unknown>;
      } catch {
        // Try next name
      }
    }
  }
  return null;
}

// ---------------------------------------------------------------------------
// Channel detection
// ---------------------------------------------------------------------------

interface ChannelInfo {
  name: string;
  hasCreds: boolean;
}

const SUPPORTED_CHANNELS = new Set([
  'whatsapp',
  'telegram',
  'slack',
  'discord',
]);

// Fields that indicate a credential is present for each channel
const CREDENTIAL_FIELDS: Record<string, string[]> = {
  telegram: ['botToken'],
  discord: ['token'],
  slack: ['botToken', 'appToken'],
  whatsapp: [], // Auth-state based, no token
  signal: ['account'],
  imessage: [],
  matrix: ['homeserverUrl', 'accessToken'],
  irc: ['server'],
  msteams: ['appId'],
  feishu: ['appId'],
  googlechat: [],
  mattermost: ['token', 'url'],
  zalo: [],
  bluebubbles: ['url'],
};

const ALL_KNOWN_CHANNELS = new Set([
  'whatsapp', 'telegram', 'slack', 'discord', 'signal',
  'imessage', 'matrix', 'irc', 'msteams', 'feishu',
  'googlechat', 'mattermost', 'zalo', 'bluebubbles',
]);

function detectChannels(
  config: Record<string, unknown>,
): ChannelInfo[] {
  // Check both config.channels.* (newer) and top-level config.* (older/legacy)
  const channelsSections: Record<string, unknown> = {};

  // Source 1: channels.* (standard location)
  const nested = config.channels as Record<string, unknown> | undefined;
  if (nested) {
    for (const [k, v] of Object.entries(nested)) {
      if (v && typeof v === 'object') channelsSections[k] = v;
    }
  }

  // Source 2: top-level keys matching known channel names (legacy format)
  for (const key of Object.keys(config)) {
    if (ALL_KNOWN_CHANNELS.has(key) && !channelsSections[key]) {
      const v = config[key];
      if (v && typeof v === 'object') channelsSections[key] = v;
    }
  }

  const results: ChannelInfo[] = [];

  for (const [name, section] of Object.entries(channelsSections)) {
    if (!section || typeof section !== 'object') continue;
    const ch = section as Record<string, unknown>;

    // Check if any credential field is present and non-empty
    const credFields = CREDENTIAL_FIELDS[name] ?? [];
    let hasCreds = false;

    for (const field of credFields) {
      const val = ch[field];
      if (val && (typeof val === 'string' || typeof val === 'object')) {
        hasCreds = true;
        break;
      }
    }

    // Also check accounts for multi-account setups
    if (!hasCreds && ch.accounts && typeof ch.accounts === 'object') {
      for (const acct of Object.values(
        ch.accounts as Record<string, unknown>,
      )) {
        if (!acct || typeof acct !== 'object') continue;
        const a = acct as Record<string, unknown>;
        for (const field of credFields) {
          if (
            a[field] &&
            (typeof a[field] === 'string' || typeof a[field] === 'object')
          ) {
            hasCreds = true;
            break;
          }
        }
        if (hasCreds) break;
      }
    }

    // WhatsApp: check for auth state directory instead of token
    if (name === 'whatsapp' && !hasCreds) {
      // Will be checked separately via agents directory
      hasCreds = false;
    }

    results.push({ name, hasCreds });
  }

  return results;
}

// ---------------------------------------------------------------------------
// Workspace scanning
// ---------------------------------------------------------------------------

const WORKSPACE_FILES = [
  'SOUL.md',
  'USER.md',
  'MEMORY.md',
  'IDENTITY.md',
  'TOOLS.md',
  'HEARTBEAT.md',
  'BOOTSTRAP.md',
  'AGENTS.md',
];

function findWorkspace(stateDir: string, config: Record<string, unknown> | null): {
  dir: string | null;
  files: string[];
} {
  // Check config-specified workspace path first (agent.workspace or agents.defaults.workspace)
  const configPaths: string[] = [];
  if (config) {
    const agentWs = (config.agent as Record<string, unknown> | undefined)?.workspace as string | undefined;
    if (agentWs) configPaths.push(agentWs.startsWith('~') ? path.join(os.homedir(), agentWs.slice(1)) : agentWs);
    const defaultsWs = ((config.agents as Record<string, unknown> | undefined)?.defaults as Record<string, unknown> | undefined)?.workspace as string | undefined;
    if (defaultsWs) configPaths.push(defaultsWs.startsWith('~') ? path.join(os.homedir(), defaultsWs.slice(1)) : defaultsWs);
  }

  // Check config-specified paths, then default locations
  const candidates = [
    ...configPaths,
    ...['workspace', 'workspace.default'].map((n) => path.join(stateDir, n)),
  ];

  for (const ws of candidates) {
    if (fs.existsSync(ws) && fs.statSync(ws).isDirectory()) {
      const found = WORKSPACE_FILES.filter((f) =>
        fs.existsSync(path.join(ws, f)),
      );
      if (found.length > 0) {
        return { dir: ws, files: found };
      }
    }
  }

  // Check agent-specific workspaces
  const agentsDir = path.join(stateDir, 'agents');
  if (fs.existsSync(agentsDir)) {
    for (const agentId of fs.readdirSync(agentsDir)) {
      for (const wsName of ['workspace', 'workspace.default']) {
        const ws = path.join(agentsDir, agentId, wsName);
        if (fs.existsSync(ws) && fs.statSync(ws).isDirectory()) {
          const found = WORKSPACE_FILES.filter((f) =>
            fs.existsSync(path.join(ws, f)),
          );
          if (found.length > 0) {
            return { dir: ws, files: found };
          }
        }
      }
    }
  }

  return { dir: null, files: [] };
}

// ---------------------------------------------------------------------------
// Daily memory file detection
// ---------------------------------------------------------------------------

function countDailyMemoryFiles(workspaceDir: string | null): number {
  if (!workspaceDir) return 0;
  const memoryDir = path.join(workspaceDir, 'memory');
  if (!fs.existsSync(memoryDir) || !fs.statSync(memoryDir).isDirectory()) {
    return 0;
  }
  try {
    return fs
      .readdirSync(memoryDir)
      .filter((f) => f.endsWith('.md'))
      .length;
  } catch {
    return 0;
  }
}

// ---------------------------------------------------------------------------
// Skills detection
// ---------------------------------------------------------------------------

interface SkillInfo {
  name: string;
  source: string; // 'workspace' | 'shared' | 'personal' | 'project'
  path: string;
}

function detectSkills(
  stateDir: string,
  workspaceDir: string | null,
): SkillInfo[] {
  const skills: SkillInfo[] = [];
  const seen = new Set<string>();

  const scanDir = (dir: string, source: string) => {
    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return;
    try {
      for (const entry of fs.readdirSync(dir)) {
        const skillDir = path.join(dir, entry);
        if (!fs.statSync(skillDir).isDirectory()) continue;
        // A directory is a skill if it contains SKILL.md
        if (fs.existsSync(path.join(skillDir, 'SKILL.md'))) {
          if (seen.has(entry)) continue;
          seen.add(entry);
          skills.push({ name: entry, source, path: skillDir });
        }
      }
    } catch {
      // ignore read errors
    }
  };

  // 1. Workspace skills
  if (workspaceDir) {
    scanDir(path.join(workspaceDir, 'skills'), 'workspace');
    // 4. Project-level shared skills
    scanDir(path.join(workspaceDir, '.agents', 'skills'), 'project');
  }

  // 2. Managed/shared skills
  scanDir(path.join(stateDir, 'skills'), 'shared');

  // 3. Personal cross-project skills
  const personalSkills = path.join(os.homedir(), '.agents', 'skills');
  scanDir(personalSkills, 'personal');

  return skills;
}

// ---------------------------------------------------------------------------
// Identity extraction
// ---------------------------------------------------------------------------

function extractIdentityName(stateDir: string, workspaceDir: string | null): string {
  if (!workspaceDir) return '';

  const identityPath = path.join(workspaceDir, 'IDENTITY.md');
  if (!fs.existsSync(identityPath)) return '';

  try {
    const content = fs.readFileSync(identityPath, 'utf-8');
    // IDENTITY.md uses key:value format, e.g. "name: Claw"
    const match = content.match(/^name:\s*(.+)/im);
    return match ? match[1].trim() : '';
  } catch {
    return '';
  }
}

// ---------------------------------------------------------------------------
// Agent detection
// ---------------------------------------------------------------------------

function detectAgents(stateDir: string): string[] {
  const agentsDir = path.join(stateDir, 'agents');
  if (!fs.existsSync(agentsDir)) return [];

  try {
    return fs
      .readdirSync(agentsDir)
      .filter((f) => {
        const p = path.join(agentsDir, f);
        return fs.statSync(p).isDirectory() && !f.startsWith('.');
      });
  } catch {
    return [];
  }
}

// ---------------------------------------------------------------------------
// Group detection — from session store and channel config
// ---------------------------------------------------------------------------

interface GroupInfo {
  channel: string;
  id: string; // Platform-specific ID (WhatsApp JID, Telegram chat ID, etc.)
  name: string;
  source: 'session' | 'config';
}

/**
 * Map an OpenClaw session key (channel:kind:id) to the v2 platform_id the
 * router stores. Mirrors src/platform-id.ts:namespacedPlatformId — Chat SDK
 * channels prefix with "<channel>:"; native channels (WhatsApp/iMessage with
 * an "@", Signal "+"/"group:") pass through unprefixed. setup/register.ts
 * applies the same normalization to whatever you pass as --platform-id, so the
 * value emitted here is what to feed register.
 *
 *   OpenClaw keys: "whatsapp:group:120...@g.us", "telegram:group:-10012345"
 *   v2 platform_id: "120...@g.us", "telegram:-10012345", "discord:12345"
 */
function toV2PlatformId(channel: string, id: string): string {
  if (id.startsWith(`${channel}:`)) return id;
  if (id.includes('@')) return id; // WhatsApp / iMessage JIDs and emails
  if (id.startsWith('+') || id.startsWith('group:')) return id; // Signal
  if (channel === 'deltachat') return id;
  return `${channel}:${id}`;
}

function detectGroups(
  stateDir: string,
  config: Record<string, unknown> | null,
  agents: string[],
): GroupInfo[] {
  const groups: GroupInfo[] = [];
  const seen = new Set<string>();

  // Source 1: Session store — scan for group session keys
  for (const agentId of agents) {
    const sessionsPath = path.join(
      stateDir,
      'agents',
      agentId,
      'sessions',
      'sessions.json',
    );
    if (!fs.existsSync(sessionsPath)) continue;

    try {
      const raw = fs.readFileSync(sessionsPath, 'utf-8');
      const data = JSON.parse(raw) as Record<string, unknown>;

      // Sessions can be stored as an object with session keys, or as
      // { sessions: { key: entry } } or { entries: [...] }
      const entries =
        (data.sessions as Record<string, unknown>) ??
        (data.entries as Record<string, unknown>) ??
        data;

      for (const [key, value] of Object.entries(entries)) {
        // Match session keys like "whatsapp:group:120...@g.us"
        // or prefixed "agent:main:whatsapp:group:120...@g.us"
        // Also match DM sessions: "whatsapp:dm:number@s.whatsapp.net"
        const match = key.match(/(\w+):(group|dm|channel):(.+)$/i);
        if (!match) continue;

        const [, channel, kind, id] = match;
        // Skip DM sessions for group detection — they're individual chats
        if (kind === 'dm') continue;
        const dedupKey = `${channel}:${id}`;
        if (seen.has(dedupKey)) continue;
        seen.add(dedupKey);

        // Try to extract display name from session entry
        let name = '';
        if (value && typeof value === 'object') {
          const entry = value as Record<string, unknown>;
          name =
            (entry.displayName as string) ??
            (entry.label as string) ??
            (entry.subject as string) ??
            '';
        }

        groups.push({
          channel,
          id,
          name: name || id,
          source: 'session',
        });
      }
    } catch {
      // Ignore parse errors
    }
  }

  // Source 2: Channel config — groups explicitly configured
  if (config) {
    const channels =
      (config.channels as Record<string, unknown> | undefined) ?? {};
    for (const [channelName, channelSection] of Object.entries(channels)) {
      if (!channelSection || typeof channelSection !== 'object') continue;
      const ch = channelSection as Record<string, unknown>;

      // WhatsApp/Telegram: channels.<channel>.groups.<groupId>
      const configGroups = ch.groups as Record<string, unknown> | undefined;
      if (configGroups) {
        for (const groupId of Object.keys(configGroups)) {
          const dedupKey = `${channelName}:${groupId}`;
          if (seen.has(dedupKey)) continue;
          seen.add(dedupKey);
          groups.push({
            channel: channelName,
            id: groupId,
            name: groupId,
            source: 'config',
          });
        }
      }

      // Discord: channels.discord.guilds.<guildId>
      if (channelName === 'discord') {
        const guilds = ch.guilds as Record<string, unknown> | undefined;
        if (guilds) {
          for (const guildId of Object.keys(guilds)) {
            const dedupKey = `discord:${guildId}`;
            if (seen.has(dedupKey)) continue;
            seen.add(dedupKey);
            groups.push({
              channel: 'discord',
              id: guildId,
              name: guildId,
              source: 'config',
            });
          }
        }
      }
    }
  }

  return groups;
}

// ---------------------------------------------------------------------------
// Cron job counting
// ---------------------------------------------------------------------------

function countCronJobs(stateDir: string): {
  count: number;
  summaries: string[];
} {
  const jobsPath = path.join(stateDir, 'cron', 'jobs.json');
  if (!fs.existsSync(jobsPath)) return { count: 0, summaries: [] };

  try {
    const raw = fs.readFileSync(jobsPath, 'utf-8');
    const data = JSON.parse(raw) as {
      jobs?: Array<{ name?: string; enabled?: boolean }>;
    };
    const jobs = data.jobs ?? [];
    const summaries = jobs
      .filter((j) => j.enabled !== false)
      .map((j) => j.name || 'unnamed')
      .slice(0, 10);
    return { count: jobs.length, summaries };
  } catch {
    return { count: 0, summaries: [] };
  }
}

// ---------------------------------------------------------------------------
// Config-registered plugins and skills (with API keys)
// ---------------------------------------------------------------------------

interface ConfigPlugin {
  name: string;
  source: 'skills.entries' | 'plugins.entries';
  hasApiKey: boolean;
}

function detectConfigPlugins(
  config: Record<string, unknown>,
): ConfigPlugin[] {
  const results: ConfigPlugin[] = [];

  // Check skills.entries (e.g. openai-whisper-api with apiKey)
  const skills = config.skills as Record<string, unknown> | undefined;
  const skillEntries = skills?.entries as Record<string, unknown> | undefined;
  if (skillEntries) {
    for (const [name, entry] of Object.entries(skillEntries)) {
      if (!entry || typeof entry !== 'object') continue;
      const e = entry as Record<string, unknown>;
      const hasKey = !!(e.apiKey || e.token || e.key);
      results.push({ name, source: 'skills.entries', hasApiKey: hasKey });
    }
  }

  // Check plugins.entries (e.g. brave with config.webSearch.apiKey)
  const plugins = config.plugins as Record<string, unknown> | undefined;
  const pluginEntries = plugins?.entries as Record<string, unknown> | undefined;
  if (pluginEntries) {
    for (const [name, entry] of Object.entries(pluginEntries)) {
      if (!entry || typeof entry !== 'object') continue;
      // Deep-search for apiKey in nested config
      const hasKey = JSON.stringify(entry).includes('apiKey');
      results.push({ name, source: 'plugins.entries', hasApiKey: hasKey });
    }
  }

  return results;
}

// ---------------------------------------------------------------------------
// MCP server detection
// ---------------------------------------------------------------------------

function detectMcpServers(
  config: Record<string, unknown>,
): string[] {
  const mcp = config.mcp as Record<string, unknown> | undefined;
  if (!mcp) return [];
  const servers = mcp.servers as Record<string, unknown> | undefined;
  if (!servers) return [];
  return Object.keys(servers);
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

function main(): void {
  const { stateDir: explicitDir } = parseArgs();
  const stateDir = resolveStateDir(explicitDir);

  if (!stateDir) {
    emitStatus({ STATUS: 'not_found' });
    return;
  }

  const config = loadConfig(stateDir);
  const channels = config ? detectChannels(config) : [];
  const { dir: workspaceDir, files: workspaceFiles } =
    findWorkspace(stateDir, config);
  const identityName = extractIdentityName(stateDir, workspaceDir);
  const agents = detectAgents(stateDir);
  const groups = detectGroups(stateDir, config, agents);
  const { count: cronCount, summaries: cronSummaries } =
    countCronJobs(stateDir);
  const mcpServers = config ? detectMcpServers(config) : [];
  const dailyMemoryFiles = countDailyMemoryFiles(workspaceDir);
  const skills = detectSkills(stateDir, workspaceDir);
  const configPlugins = config ? detectConfigPlugins(config) : [];

  // Format channels as "name(has_creds)" or "name(no_creds)"
  const channelList = channels
    .map((c) => `${c.name}(${c.hasCreds ? 'has_creds' : 'no_creds'})`)
    .join(',');

  // Separate supported vs unsupported
  const unsupported = channels
    .filter((c) => !SUPPORTED_CHANNELS.has(c.name))
    .map((c) => c.name)
    .join(',');

  // Format groups as "channel:id(name)=>v2_platform_id". The right-hand value
  // is what to pass as --platform-id to setup/register.ts.
  const groupList = groups
    .map(
      (g) =>
        `${g.channel}:${g.id}(${g.name})=>${toV2PlatformId(g.channel, g.id)}`,
    )
    .join('|');

  // Format skills as "name(source)" list
  const skillList = skills
    .map((s) => `${s.name}(${s.source})`)
    .join(',');

  // Dump raw top-level config keys so Claude can see what exists
  // beyond what this script specifically detects
  const configTopKeys = config ? Object.keys(config).sort().join(',') : 'none';
  const configChannelKeys = config?.channels
    ? Object.keys(config.channels as Record<string, unknown>).sort().join(',')
    : 'none';

  // List files/dirs at the state dir root for manual inspection
  let stateDirContents = 'unknown';
  try {
    stateDirContents = fs
      .readdirSync(stateDir)
      .filter((f) => !f.startsWith('.'))
      .sort()
      .join(',');
  } catch {
    // ignore
  }

  emitStatus({
    STATUS: 'found',
    STATE_DIR: stateDir,
    CONFIG_FOUND: config !== null,
    CONFIG_TOP_KEYS: configTopKeys,
    CONFIG_CHANNEL_KEYS: configChannelKeys,
    STATE_DIR_CONTENTS: stateDirContents,
    CHANNELS: channelList || 'none',
    UNSUPPORTED_CHANNELS: unsupported || 'none',
    WORKSPACE_DIR: workspaceDir || 'not_found',
    WORKSPACE_FILES: workspaceFiles.join(',') || 'none',
    IDENTITY_NAME: identityName || 'unknown',
    AGENT_COUNT: agents.length,
    AGENT_IDS: agents.join(',') || 'none',
    GROUPS: groupList || 'none',
    GROUP_COUNT: groups.length,
    DAILY_MEMORY_FILES: dailyMemoryFiles,
    SKILL_COUNT: skills.length,
    SKILLS: skillList || 'none',
    CONFIG_PLUGINS: configPlugins.map((p) => `${p.name}(${p.source}${p.hasApiKey ? ',has_key' : ''})`).join(',') || 'none',
    CONFIG_PLUGIN_COUNT: configPlugins.length,
    CRON_JOBS: cronCount,
    CRON_SUMMARIES: cronSummaries.join('|') || 'none',
    MCP_SERVERS: mcpServers.join(',') || 'none',
  });
}

main();
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall