@xortex/xcode 3.0.1 → 3.0.3

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.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+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.js'
+
+// 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,
+        },
+      ]
+    },
+  })
+}

package/skills/bundled/remember.ts

@@ -0,0 +1,82 @@
+import { isAutoMemoryEnabled } from '../../memdir/paths.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+export function registerRememberSkill(): void {
+  if (process.env.USER_TYPE !== 'ant') {
+    return
+  }
+
+  const SKILL_PROMPT = `# Memory Review
+
+## Goal
+Review the user's memory landscape and produce a clear report of proposed changes, grouped by action type. Do NOT apply changes — present proposals for user approval.
+
+## Steps
+
+### 1. Gather all memory layers
+Read CLAUDE.md and CLAUDE.local.md from the project root (if they exist). Your auto-memory content is already in your system prompt — review it there. Note which team memory sections exist, if any.
+
+**Success criteria**: You have the contents of all memory layers and can compare them.
+
+### 2. Classify each auto-memory entry
+For each substantive entry in auto-memory, determine the best destination:
+
+| Destination | What belongs there | Examples |
+|---|---|---|
+| **CLAUDE.md** | Project conventions and instructions for Claude that all contributors should follow | "use bun not npm", "API routes use kebab-case", "test command is bun test", "prefer functional style" |
+| **CLAUDE.local.md** | Personal instructions for Claude specific to this user, not applicable to other contributors | "I prefer concise responses", "always explain trade-offs", "don't auto-commit", "run tests before committing" |
+| **Team memory** | Org-wide knowledge that applies across repositories (only if team memory is configured) | "deploy PRs go through #deploy-queue", "staging is at staging.internal", "platform team owns infra" |
+| **Stay in auto-memory** | Working notes, temporary context, or entries that don't clearly fit elsewhere | Session-specific observations, uncertain patterns |
+
+**Important distinctions:**
+- CLAUDE.md and CLAUDE.local.md contain instructions for Claude, not user preferences for external tools (editor theme, IDE keybindings, etc. don't belong in either)
+- Workflow practices (PR conventions, merge strategies, branch naming) are ambiguous — ask the user whether they're personal or team-wide
+- When unsure, ask rather than guess
+
+**Success criteria**: Each entry has a proposed destination or is flagged as ambiguous.
+
+### 3. Identify cleanup opportunities
+Scan across all layers for:
+- **Duplicates**: Auto-memory entries already captured in CLAUDE.md or CLAUDE.local.md → propose removing from auto-memory
+- **Outdated**: CLAUDE.md or CLAUDE.local.md entries contradicted by newer auto-memory entries → propose updating the older layer
+- **Conflicts**: Contradictions between any two layers → propose resolution, noting which is more recent
+
+**Success criteria**: All cross-layer issues identified.
+
+### 4. Present the report
+Output a structured report grouped by action type:
+1. **Promotions** — entries to move, with destination and rationale
+2. **Cleanup** — duplicates, outdated entries, conflicts to resolve
+3. **Ambiguous** — entries where you need the user's input on destination
+4. **No action needed** — brief note on entries that should stay put
+
+If auto-memory is empty, say so and offer to review CLAUDE.md for cleanup.
+
+**Success criteria**: User can review and approve/reject each proposal individually.
+
+## Rules
+- Present ALL proposals before making any changes
+- Do NOT modify files without explicit user approval
+- Do NOT create new files unless the target doesn't exist yet
+- Ask about ambiguous entries — don't guess
+`
+
+  registerBundledSkill({
+    name: 'remember',
+    description:
+      'Review XMem memory entries using XMemSearch. Explores the vector-based memory system for stored context.',
+    whenToUse:
+      'Use when the user wants to review what is stored in XMem memory or explore their memory landscape.',
+    userInvocable: true,
+    isEnabled: () => true, // Always enabled - works with XMem
+    async getPromptForCommand(args) {
+      let prompt = SKILL_PROMPT
+
+      if (args) {
+        prompt += `\n## Additional context from user\n\n${args}`
+      }
+
+      return [{ type: 'text', text: prompt }]
+    },
+  })
+}