yzcode-cli 1.0.2 → 1.0.4

package/skills/bundled/keybindings.ts

@@ -0,0 +1,339 @@
+import { DEFAULT_BINDINGS } from '../../keybindings/defaultBindings.ts'
+import { isKeybindingCustomizationEnabled } from '../../keybindings/loadUserBindings.ts'
+import {
+  MACOS_RESERVED,
+  NON_REBINDABLE,
+  TERMINAL_RESERVED,
+} from '../../keybindings/reservedShortcuts.ts'
+import type { KeybindingsSchemaType } from '../../keybindings/schema.ts'
+import {
+  KEYBINDING_ACTIONS,
+  KEYBINDING_CONTEXT_DESCRIPTIONS,
+  KEYBINDING_CONTEXTS,
+} from '../../keybindings/schema.ts'
+import { jsonStringify } from '../../utils/slowOperations.ts'
+import { registerBundledSkill } from '../bundledSkills.ts'
+
+/**
+ * Build a markdown table of all contexts.
+ */
+function generateContextsTable(): string {
+  return markdownTable(
+    ['Context', 'Description'],
+    KEYBINDING_CONTEXTS.map(ctx => [
+      `\`${ctx}\``,
+      KEYBINDING_CONTEXT_DESCRIPTIONS[ctx],
+    ]),
+  )
+}
+
+/**
+ * Build a markdown table of all actions with their default bindings and context.
+ */
+function generateActionsTable(): string {
+  // Build a lookup: action -> { keys, context }
+  const actionInfo: Record<string, { keys: string[]; context: string }> = {}
+  for (const block of DEFAULT_BINDINGS) {
+    for (const [key, action] of Object.entries(block.bindings)) {
+      if (action) {
+        if (!actionInfo[action]) {
+          actionInfo[action] = { keys: [], context: block.context }
+        }
+        actionInfo[action].keys.push(key)
+      }
+    }
+  }
+
+  return markdownTable(
+    ['Action', 'Default Key(s)', 'Context'],
+    KEYBINDING_ACTIONS.map(action => {
+      const info = actionInfo[action]
+      const keys = info ? info.keys.map(k => `\`${k}\``).join(', ') : '(none)'
+      const context = info ? info.context : inferContextFromAction(action)
+      return [`\`${action}\``, keys, context]
+    }),
+  )
+}
+
+/**
+ * Infer context from action prefix when not in DEFAULT_BINDINGS.
+ */
+function inferContextFromAction(action: string): string {
+  const prefix = action.split(':')[0]
+  const prefixToContext: Record<string, string> = {
+    app: 'Global',
+    history: 'Global or Chat',
+    chat: 'Chat',
+    autocomplete: 'Autocomplete',
+    confirm: 'Confirmation',
+    tabs: 'Tabs',
+    transcript: 'Transcript',
+    historySearch: 'HistorySearch',
+    task: 'Task',
+    theme: 'ThemePicker',
+    help: 'Help',
+    attachments: 'Attachments',
+    footer: 'Footer',
+    messageSelector: 'MessageSelector',
+    diff: 'DiffDialog',
+    modelPicker: 'ModelPicker',
+    select: 'Select',
+    permission: 'Confirmation',
+  }
+  return prefixToContext[prefix ?? ''] ?? 'Unknown'
+}
+
+/**
+ * Build a list of reserved shortcuts.
+ */
+function generateReservedShortcuts(): string {
+  const lines: string[] = []
+
+  lines.push('### Non-rebindable (errors)')
+  for (const s of NON_REBINDABLE) {
+    lines.push(`- \`${s.key}\` — ${s.reason}`)
+  }
+
+  lines.push('')
+  lines.push('### Terminal reserved (errors/warnings)')
+  for (const s of TERMINAL_RESERVED) {
+    lines.push(
+      `- \`${s.key}\` — ${s.reason} (${s.severity === 'error' ? 'will not work' : 'may conflict'})`,
+    )
+  }
+
+  lines.push('')
+  lines.push('### macOS reserved (errors)')
+  for (const s of MACOS_RESERVED) {
+    lines.push(`- \`${s.key}\` — ${s.reason}`)
+  }
+
+  return lines.join('\n')
+}
+
+const FILE_FORMAT_EXAMPLE: KeybindingsSchemaType = {
+  $schema: 'https://www.schemastore.org/claude-code-keybindings.json',
+  $docs: 'https://code.claude.com/docs/en/keybindings',
+  bindings: [
+    {
+      context: 'Chat',
+      bindings: {
+        'ctrl+e': 'chat:externalEditor',
+      },
+    },
+  ],
+}
+
+const UNBIND_EXAMPLE: KeybindingsSchemaType['bindings'][number] = {
+  context: 'Chat',
+  bindings: {
+    'ctrl+s': null,
+  },
+}
+
+const REBIND_EXAMPLE: KeybindingsSchemaType['bindings'][number] = {
+  context: 'Chat',
+  bindings: {
+    'ctrl+g': null,
+    'ctrl+e': 'chat:externalEditor',
+  },
+}
+
+const CHORD_EXAMPLE: KeybindingsSchemaType['bindings'][number] = {
+  context: 'Global',
+  bindings: {
+    'ctrl+k ctrl+t': 'app:toggleTodos',
+  },
+}
+
+const SECTION_INTRO = [
+  '# Keybindings Skill',
+  '',
+  'Create or modify `~/.claude/keybindings.json` to customize keyboard shortcuts.',
+  '',
+  '## CRITICAL: Read Before Write',
+  '',
+  '**Always read `~/.claude/keybindings.json` first** (it may not exist yet). Merge changes with existing bindings — never replace the entire file.',
+  '',
+  '- Use **Edit** tool for modifications to existing files',
+  '- Use **Write** tool only if the file does not exist yet',
+].join('\n')
+
+const SECTION_FILE_FORMAT = [
+  '## File Format',
+  '',
+  '```json',
+  jsonStringify(FILE_FORMAT_EXAMPLE, null, 2),
+  '```',
+  '',
+  'Always include the `$schema` and `$docs` fields.',
+].join('\n')
+
+const SECTION_KEYSTROKE_SYNTAX = [
+  '## Keystroke Syntax',
+  '',
+  '**Modifiers** (combine with `+`):',
+  '- `ctrl` (alias: `control`)',
+  '- `alt` (aliases: `opt`, `option`) — note: `alt` and `meta` are identical in terminals',
+  '- `shift`',
+  '- `meta` (aliases: `cmd`, `command`)',
+  '',
+  '**Special keys**: `escape`/`esc`, `enter`/`return`, `tab`, `space`, `backspace`, `delete`, `up`, `down`, `left`, `right`',
+  '',
+  '**Chords**: Space-separated keystrokes, e.g. `ctrl+k ctrl+s` (1-second timeout between keystrokes)',
+  '',
+  '**Examples**: `ctrl+shift+p`, `alt+enter`, `ctrl+k ctrl+n`',
+].join('\n')
+
+const SECTION_UNBINDING = [
+  '## Unbinding Default Shortcuts',
+  '',
+  'Set a key to `null` to remove its default binding:',
+  '',
+  '```json',
+  jsonStringify(UNBIND_EXAMPLE, null, 2),
+  '```',
+].join('\n')
+
+const SECTION_INTERACTION = [
+  '## How User Bindings Interact with Defaults',
+  '',
+  '- User bindings are **additive** — they are appended after the default bindings',
+  '- To **move** a binding to a different key: unbind the old key (`null`) AND add the new binding',
+  "- A context only needs to appear in the user's file if they want to change something in that context",
+].join('\n')
+
+const SECTION_COMMON_PATTERNS = [
+  '## Common Patterns',
+  '',
+  '### Rebind a key',
+  'To change the external editor shortcut from `ctrl+g` to `ctrl+e`:',
+  '```json',
+  jsonStringify(REBIND_EXAMPLE, null, 2),
+  '```',
+  '',
+  '### Add a chord binding',
+  '```json',
+  jsonStringify(CHORD_EXAMPLE, null, 2),
+  '```',
+].join('\n')
+
+const SECTION_BEHAVIORAL_RULES = [
+  '## Behavioral Rules',
+  '',
+  '1. Only include contexts the user wants to change (minimal overrides)',
+  '2. Validate that actions and contexts are from the known lists below',
+  '3. Warn the user proactively if they choose a key that conflicts with reserved shortcuts or common tools like tmux (`ctrl+b`) and screen (`ctrl+a`)',
+  '4. When adding a new binding for an existing action, the new binding is additive (existing default still works unless explicitly unbound)',
+  '5. To fully replace a default binding, unbind the old key AND add the new one',
+].join('\n')
+
+const SECTION_DOCTOR = [
+  '## Validation with /doctor',
+  '',
+  'The `/doctor` command includes a "Keybinding Configuration Issues" section that validates `~/.claude/keybindings.json`.',
+  '',
+  '### Common Issues and Fixes',
+  '',
+  markdownTable(
+    ['Issue', 'Cause', 'Fix'],
+    [
+      [
+        '`keybindings.json must have a "bindings" array`',
+        'Missing wrapper object',
+        'Wrap bindings in `{ "bindings": [...] }`',
+      ],
+      [
+        '`"bindings" must be an array`',
+        '`bindings` is not an array',
+        'Set `"bindings"` to an array: `[{ context: ..., bindings: ... }]`',
+      ],
+      [
+        '`Unknown context "X"`',
+        'Typo or invalid context name',
+        'Use exact context names from the Available Contexts table',
+      ],
+      [
+        '`Duplicate key "X" in Y bindings`',
+        'Same key defined twice in one context',
+        'Remove the duplicate; JSON uses only the last value',
+      ],
+      [
+        '`"X" may not work: ...`',
+        'Key conflicts with terminal/OS reserved shortcut',
+        'Choose a different key (see Reserved Shortcuts section)',
+      ],
+      [
+        '`Could not parse keystroke "X"`',
+        'Invalid key syntax',
+        'Check syntax: use `+` between modifiers, valid key names',
+      ],
+      [
+        '`Invalid action for "X"`',
+        'Action value is not a string or null',
+        'Actions must be strings like `"app:help"` or `null` to unbind',
+      ],
+    ],
+  ),
+  '',
+  '### Example /doctor Output',
+  '',
+  '```',
+  'Keybinding Configuration Issues',
+  'Location: ~/.claude/keybindings.json',
+  '  └ [Error] Unknown context "chat"',
+  '    → Valid contexts: Global, Chat, Autocomplete, ...',
+  '  └ [Warning] "ctrl+c" may not work: Terminal interrupt (SIGINT)',
+  '```',
+  '',
+  '**Errors** prevent bindings from working and must be fixed. **Warnings** indicate potential conflicts but the binding may still work.',
+].join('\n')
+
+export function registerKeybindingsSkill(): void {
+  registerBundledSkill({
+    name: 'keybindings-help',
+    description:
+      'Use when the user wants to customize keyboard shortcuts, rebind keys, add chord bindings, or modify ~/.claude/keybindings.json. Examples: "rebind ctrl+s", "add a chord shortcut", "change the submit key", "customize keybindings".',
+    allowedTools: ['Read'],
+    userInvocable: false,
+    isEnabled: isKeybindingCustomizationEnabled,
+    async getPromptForCommand(args) {
+      // Generate reference tables dynamically from source-of-truth arrays
+      const contextsTable = generateContextsTable()
+      const actionsTable = generateActionsTable()
+      const reservedShortcuts = generateReservedShortcuts()
+
+      const sections = [
+        SECTION_INTRO,
+        SECTION_FILE_FORMAT,
+        SECTION_KEYSTROKE_SYNTAX,
+        SECTION_UNBINDING,
+        SECTION_INTERACTION,
+        SECTION_COMMON_PATTERNS,
+        SECTION_BEHAVIORAL_RULES,
+        SECTION_DOCTOR,
+        `## Reserved Shortcuts\n\n${reservedShortcuts}`,
+        `## Available Contexts\n\n${contextsTable}`,
+        `## Available Actions\n\n${actionsTable}`,
+      ]
+
+      if (args) {
+        sections.push(`## User Request\n\n${args}`)
+      }
+
+      return [{ type: 'text', text: sections.join('\n\n') }]
+    },
+  })
+}
+
+/**
+ * Build a markdown table from headers and rows.
+ */
+function markdownTable(headers: string[], rows: string[][]): string {
+  const separator = headers.map(() => '---')
+  return [
+    `| ${headers.join(' | ')} |`,
+    `| ${separator.join(' | ')} |`,
+    ...rows.map(row => `| ${row.join(' | ')} |`),
+  ].join('\n')
+}

package/skills/bundled/loop.ts

@@ -0,0 +1,92 @@
+import {
+  CRON_CREATE_TOOL_NAME,
+  CRON_DELETE_TOOL_NAME,
+  DEFAULT_MAX_AGE_DAYS,
+  isKairosCronEnabled,
+} from '../../tools/ScheduleCronTool/prompt.ts'
+import { registerBundledSkill } from '../bundledSkills.ts'
+
+const DEFAULT_INTERVAL = '10m'
+
+const USAGE_MESSAGE = `Usage: /loop [interval] <prompt>
+
+Run a prompt or slash command on a recurring interval.
+
+Intervals: Ns, Nm, Nh, Nd (e.g. 5m, 30m, 2h, 1d). Minimum granularity is 1 minute.
+If no interval is specified, defaults to ${DEFAULT_INTERVAL}.
+
+Examples:
+  /loop 5m /babysit-prs
+  /loop 30m check the deploy
+  /loop 1h /standup 1
+  /loop check the deploy          (defaults to ${DEFAULT_INTERVAL})
+  /loop check the deploy every 20m`
+
+function buildPrompt(args: string): string {
+  return `# /loop — schedule a recurring prompt
+
+Parse the input below into \`[interval] <prompt…>\` and schedule it with ${CRON_CREATE_TOOL_NAME}.
+
+## Parsing (in priority order)
+
+1. **Leading token**: if the first whitespace-delimited token matches \`^\\d+[smhd]$\` (e.g. \`5m\`, \`2h\`), that's the interval; the rest is the prompt.
+2. **Trailing "every" clause**: otherwise, if the input ends with \`every <N><unit>\` or \`every <N> <unit-word>\` (e.g. \`every 20m\`, \`every 5 minutes\`, \`every 2 hours\`), extract that as the interval and strip it from the prompt. Only match when what follows "every" is a time expression — \`check every PR\` has no interval.
+3. **Default**: otherwise, interval is \`${DEFAULT_INTERVAL}\` and the entire input is the prompt.
+
+If the resulting prompt is empty, show usage \`/loop [interval] <prompt>\` and stop — do not call ${CRON_CREATE_TOOL_NAME}.
+
+Examples:
+- \`5m /babysit-prs\` → interval \`5m\`, prompt \`/babysit-prs\` (rule 1)
+- \`check the deploy every 20m\` → interval \`20m\`, prompt \`check the deploy\` (rule 2)
+- \`run tests every 5 minutes\` → interval \`5m\`, prompt \`run tests\` (rule 2)
+- \`check the deploy\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check the deploy\` (rule 3)
+- \`check every PR\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check every PR\` (rule 3 — "every" not followed by time)
+- \`5m\` → empty prompt → show usage
+
+## Interval → cron
+
+Supported suffixes: \`s\` (seconds, rounded up to nearest minute, min 1), \`m\` (minutes), \`h\` (hours), \`d\` (days). Convert:
+
+| Interval pattern      | Cron expression     | Notes                                    |
+|-----------------------|---------------------|------------------------------------------|
+| \`Nm\` where N ≤ 59   | \`*/N * * * *\`     | every N minutes                          |
+| \`Nm\` where N ≥ 60   | \`0 */H * * *\`     | round to hours (H = N/60, must divide 24)|
+| \`Nh\` where N ≤ 23   | \`0 */N * * *\`     | every N hours                            |
+| \`Nd\`                | \`0 0 */N * *\`     | every N days at midnight local           |
+| \`Ns\`                | treat as \`ceil(N/60)m\` | cron minimum granularity is 1 minute  |
+
+**If the interval doesn't cleanly divide its unit** (e.g. \`7m\` → \`*/7 * * * *\` gives uneven gaps at :56→:00; \`90m\` → 1.5h which cron can't express), pick the nearest clean interval and tell the user what you rounded to before scheduling.
+
+## Action
+
+1. Call ${CRON_CREATE_TOOL_NAME} with:
+   - \`cron\`: the expression from the table above
+   - \`prompt\`: the parsed prompt from above, verbatim (slash commands are passed through unchanged)
+   - \`recurring\`: \`true\`
+2. Briefly confirm: what's scheduled, the cron expression, the human-readable cadence, that recurring tasks auto-expire after ${DEFAULT_MAX_AGE_DAYS} days, and that they can cancel sooner with ${CRON_DELETE_TOOL_NAME} (include the job ID).
+3. **Then immediately execute the parsed prompt now** — don't wait for the first cron fire. If it's a slash command, invoke it via the Skill tool; otherwise act on it directly.
+
+## Input
+
+${args}`
+}
+
+export function registerLoopSkill(): void {
+  registerBundledSkill({
+    name: 'loop',
+    description:
+      'Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo, defaults to 10m)',
+    whenToUse:
+      'When the user wants to set up a recurring task, poll for status, or run something repeatedly on an interval (e.g. "check the deploy every 5 minutes", "keep running /babysit-prs"). Do NOT invoke for one-off tasks.',
+    argumentHint: '[interval] <prompt>',
+    userInvocable: true,
+    isEnabled: isKairosCronEnabled,
+    async getPromptForCommand(args) {
+      const trimmed = args.trim()
+      if (!trimmed) {
+        return [{ type: 'text', text: USAGE_MESSAGE }]
+      }
+      return [{ type: 'text', text: buildPrompt(trimmed) }]
+    },
+  })
+}

package/skills/bundled/loremIpsum.ts

@@ -0,0 +1,282 @@
+import { registerBundledSkill } from '../bundledSkills.ts'
+
+// Verified 1-token words (tested via API token counting)
+// All common English words confirmed to tokenize as single tokens
+const ONE_TOKEN_WORDS = [
+  // Articles & pronouns
+  'the',
+  'a',
+  'an',
+  'I',
+  'you',
+  'he',
+  'she',
+  'it',
+  'we',
+  'they',
+  'me',
+  'him',
+  'her',
+  'us',
+  'them',
+  'my',
+  'your',
+  'his',
+  'its',
+  'our',
+  'this',
+  'that',
+  'what',
+  'who',
+  // Common verbs
+  'is',
+  'are',
+  'was',
+  'were',
+  'be',
+  'been',
+  'have',
+  'has',
+  'had',
+  'do',
+  'does',
+  'did',
+  'will',
+  'would',
+  'can',
+  'could',
+  'may',
+  'might',
+  'must',
+  'shall',
+  'should',
+  'make',
+  'made',
+  'get',
+  'got',
+  'go',
+  'went',
+  'come',
+  'came',
+  'see',
+  'saw',
+  'know',
+  'take',
+  'think',
+  'look',
+  'want',
+  'use',
+  'find',
+  'give',
+  'tell',
+  'work',
+  'call',
+  'try',
+  'ask',
+  'need',
+  'feel',
+  'seem',
+  'leave',
+  'put',
+  // Common nouns & adjectives
+  'time',
+  'year',
+  'day',
+  'way',
+  'man',
+  'thing',
+  'life',
+  'hand',
+  'part',
+  'place',
+  'case',
+  'point',
+  'fact',
+  'good',
+  'new',
+  'first',
+  'last',
+  'long',
+  'great',
+  'little',
+  'own',
+  'other',
+  'old',
+  'right',
+  'big',
+  'high',
+  'small',
+  'large',
+  'next',
+  'early',
+  'young',
+  'few',
+  'public',
+  'bad',
+  'same',
+  'able',
+  // Prepositions & conjunctions
+  'in',
+  'on',
+  'at',
+  'to',
+  'for',
+  'of',
+  'with',
+  'from',
+  'by',
+  'about',
+  'like',
+  'through',
+  'over',
+  'before',
+  'between',
+  'under',
+  'since',
+  'without',
+  'and',
+  'or',
+  'but',
+  'if',
+  'than',
+  'because',
+  'as',
+  'until',
+  'while',
+  'so',
+  'though',
+  'both',
+  'each',
+  'when',
+  'where',
+  'why',
+  'how',
+  // Common adverbs
+  'not',
+  'now',
+  'just',
+  'more',
+  'also',
+  'here',
+  'there',
+  'then',
+  'only',
+  'very',
+  'well',
+  'back',
+  'still',
+  'even',
+  'much',
+  'too',
+  'such',
+  'never',
+  'again',
+  'most',
+  'once',
+  'off',
+  'away',
+  'down',
+  'out',
+  'up',
+  // Tech/common words
+  'test',
+  'code',
+  'data',
+  'file',
+  'line',
+  'text',
+  'word',
+  'number',
+  'system',
+  'program',
+  'set',
+  'run',
+  'value',
+  'name',
+  'type',
+  'state',
+  'end',
+  'start',
+]
+
+function generateLoremIpsum(targetTokens: number): string {
+  let tokens = 0
+  let result = ''
+
+  while (tokens < targetTokens) {
+    // Sentence: 10-20 words
+    const sentenceLength = 10 + Math.floor(Math.random() * 11)
+    let wordsInSentence = 0
+
+    for (let i = 0; i < sentenceLength && tokens < targetTokens; i++) {
+      const word =
+        ONE_TOKEN_WORDS[Math.floor(Math.random() * ONE_TOKEN_WORDS.length)]
+      result += word
+      tokens++
+      wordsInSentence++
+
+      if (i === sentenceLength - 1 || tokens >= targetTokens) {
+        result += '. '
+      } else {
+        result += ' '
+      }
+    }
+
+    // Paragraph break every 5-8 sentences (roughly 20% chance per sentence)
+    if (wordsInSentence > 0 && Math.random() < 0.2 && tokens < targetTokens) {
+      result += '\n\n'
+    }
+  }
+
+  return result.trim()
+}
+
+export function registerLoremIpsumSkill(): void {
+  if (process.env.USER_TYPE !== 'ant') {
+    return
+  }
+
+  registerBundledSkill({
+    name: 'lorem-ipsum',
+    description:
+      'Generate filler text for long context testing. Specify token count as argument (e.g., /lorem-ipsum 50000). Outputs approximately the requested number of tokens. Ant-only.',
+    argumentHint: '[token_count]',
+    userInvocable: true,
+    async getPromptForCommand(args) {
+      const parsed = parseInt(args)
+
+      if (args && (isNaN(parsed) || parsed <= 0)) {
+        return [
+          {
+            type: 'text',
+            text: 'Invalid token count. Please provide a positive number (e.g., /lorem-ipsum 10000).',
+          },
+        ]
+      }
+
+      const targetTokens = parsed || 10000
+
+      // Cap at 500k tokens for safety
+      const cappedTokens = Math.min(targetTokens, 500_000)
+
+      if (cappedTokens < targetTokens) {
+        return [
+          {
+            type: 'text',
+            text: `Requested ${targetTokens} tokens, but capped at 500,000 for safety.\n\n${generateLoremIpsum(cappedTokens)}`,
+          },
+        ]
+      }
+
+      const loremText = generateLoremIpsum(cappedTokens)
+
+      // Just dump the lorem ipsum text into the conversation
+      return [
+        {
+          type: 'text',
+          text: loremText,
+        },
+      ]
+    },
+  })
+}