@xortex/xcode 3.0.0

package/tools/XMemRetrieveTool/XMemRetrieveTool.ts

@@ -0,0 +1,177 @@
+import React from 'react'
+import { Text } from '../../ink.js'
+import { z } from 'zod/v4'
+import type { ValidationResult } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { xmemClient } from '../../utils/xmem.js'
+import { getInitialSettings } from '../../utils/settings/settings.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { XMEM_RETRIEVE_TOOL_NAME, DESCRIPTION } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    query: z
+      .string()
+      .describe('The search query describing what information you need from memory'),
+    max_results: z
+      .number()
+      .optional()
+      .describe('Maximum number of memory entries to retrieve (default: 3)'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    success: z.boolean().describe('Whether the retrieval was successful'),
+    memories: z
+      .array(
+        z.object({
+          content: z.string().describe('The retrieved memory content'),
+          relevance: z.number().optional().describe('Relevance score if available'),
+        }),
+      )
+      .describe('Retrieved memories relevant to the query'),
+    answer: z
+      .string()
+      .optional()
+      .describe('Consolidated answer from retrieved memories'),
+    message: z.string().describe('Status message'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const XMemRetrieveTool = buildTool({
+  name: XMEM_RETRIEVE_TOOL_NAME,
+  searchHint: 'retrieve relevant memories from long-term storage',
+  maxResultSizeChars: 50_000,
+  async description() {
+    return DESCRIPTION
+  },
+  userFacingName() {
+    return 'XMem Retrieve'
+  },
+  getToolUseSummary(input) {
+    return `Retrieving memories: ${input.query.substring(0, 50)}...`
+  },
+  getActivityDescription(input) {
+    return `Retrieving memories: ${input.query.substring(0, 40)}...`
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return `Retrieve memory: ${input.query}`
+  },
+  isSearchOrReadCommand() {
+    return { isSearch: true, isRead: true }
+  },
+  async validateInput(): Promise<ValidationResult> {
+    // XMem is always enabled by default now
+    return { result: true }
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderToolUseMessage(input) {
+    return `Retrieving from XMem memory: "${input.query.substring(0, 60)}${input.query.length > 60 ? '...' : ''}"`
+  },
+  renderToolUseErrorMessage() {
+    return React.createElement(Text, null, `Failed to retrieve memories`);
+  },
+  renderToolResultMessage(output) {
+    if (!output.success) {
+      return React.createElement(Text, { color: 'error' }, `❌ Failed: ${output.message}`);
+    }
+    if (output.memories.length === 0) {
+      return React.createElement(Text, null, `No relevant memories found`);
+    }
+    return React.createElement(Text, null, `✅ Found ${output.memories.length} relevant memory${output.memories.length > 1 ? 'ies' : ''}`);
+  },
+  async call(input) {
+    console.error(`[XMem Retrieve] Query: "${input.query.substring(0, 50)}..."`)
+    
+    const start = Date.now()
+    
+    try {
+      const result = await xmemClient.retrieve({
+        query: input.query,
+        user_id: 'default_user',
+      })
+      
+      const duration = Date.now() - start
+      console.error(`[XMem Retrieve] ✅ Retrieved in ${duration}ms`)
+      console.error(`[XMem Retrieve] Answer: ${result.answer.substring(0, 100)}${result.answer.length > 100 ? '...' : ''}`)
+      
+      // Parse the answer into memory entries
+      const memories = result.answer
+        ? [{ content: result.answer, relevance: 1.0 }]
+        : []
+      
+      return {
+        data: {
+          success: true,
+          memories,
+          answer: result.answer,
+          message: `Retrieved ${memories.length} relevant memories`,
+        },
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error)
+      console.error(`[XMem Retrieve] ❌ Failed: ${errorMsg}`)
+      
+      return {
+        data: {
+          success: false,
+          memories: [],
+          message: `Failed to retrieve memories: ${errorMsg}`,
+        },
+      }
+    }
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    if (!output.success) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: `Error: ${output.message}`,
+        is_error: true,
+      }
+    }
+    
+    if (output.memories.length === 0) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: 'No relevant memories found for this query.',
+      }
+    }
+    
+    const content = [
+      `Retrieved ${output.memories.length} relevant memory${output.memories.length > 1 ? 'ies' : ''}:`,
+      '',
+      ...output.memories.map((m, i) => 
+        `[${i + 1}] ${m.content}${m.relevance ? ` (relevance: ${m.relevance.toFixed(2)})` : ''}`
+      ),
+      '',
+      output.answer ? `Consolidated answer: ${output.answer}` : '',
+    ].filter(Boolean).join('\n')
+    
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

package/tools/XMemRetrieveTool/prompt.ts

@@ -0,0 +1,16 @@
+export const XMEM_RETRIEVE_TOOL_NAME = 'XMemRetrieve'
+
+export const DESCRIPTION = `Retrieve relevant memories from long-term XMem storage to help answer the current query.
+
+**THINK LIKE A HUMAN**: A human mind recalls past knowledge before starting a task. Before using ANY other tools (like reading files or searching code) to solve a problem or start a new task, ALWAYS call ${XMEM_RETRIEVE_TOOL_NAME} first with the context of the user's request.
+
+Use this tool when:
+- Starting a new task to recall context, preferences, or prior related work.
+- The user's question mentions "remember", "before", "last time", "previously", "as we discussed".
+- The question refers to personal details ("my name", "my preference", "my project").
+- You're unsure about context that might have been established in previous conversations.
+- You need to personalize the response based on past interactions.
+
+If the memory gives you the answer or context, use it. If no relevant memory is found, ONLY THEN proceed to explore the codebase or solve the issue from scratch. You can also use a hybrid approach: retrieve from memory to get initial context, then use other tools (like file reading or searching) to expand on it. You can call the memory retrieval tool multiple times during a task if new questions arise that might benefit from past context.
+
+Call this tool with a search query describing what you need to know, then use the results to inform your response.`

package/tools/XMemSearchTool/XMemSearchTool.ts

@@ -0,0 +1,172 @@
+import React from 'react'
+import { Text } from '../../ink.js'
+import { z } from 'zod/v4'
+import type { ValidationResult } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { xmemClient } from '../../utils/xmem.js'
+import { getInitialSettings } from '../../utils/settings/settings.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { XMEM_SEARCH_TOOL_NAME, DESCRIPTION } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    query: z
+      .string()
+      .describe('The search query to find specific memories'),
+    limit: z
+      .number()
+      .optional()
+      .describe('Maximum results to return (default: 10)'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    success: z.boolean().describe('Whether the search was successful'),
+    results: z
+      .array(
+        z.object({
+          content: z.string().describe('The memory content'),
+          score: z.number().optional().describe('Search relevance score'),
+        }),
+      )
+      .describe('Search results matching the query'),
+    count: z.number().describe('Total number of results found'),
+    message: z.string().describe('Status message'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const XMemSearchTool = buildTool({
+  name: XMEM_SEARCH_TOOL_NAME,
+  searchHint: 'search through stored memories',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return DESCRIPTION
+  },
+  userFacingName() {
+    return 'XMem Search'
+  },
+  getToolUseSummary(input) {
+    return `Searching memories: ${input.query.substring(0, 50)}...`
+  },
+  getActivityDescription(input) {
+    return `Searching memories: ${input.query.substring(0, 40)}...`
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return `Search memory: ${input.query}`
+  },
+  isSearchOrReadCommand() {
+    return { isSearch: true, isRead: true }
+  },
+  async validateInput(): Promise<ValidationResult> {
+    // XMem is always enabled by default now
+    return { result: true }
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderToolUseMessage(input) {
+    return `Searching XMem memory: "${input.query.substring(0, 60)}${input.query.length > 60 ? '...' : ''}"`
+  },
+  renderToolUseErrorMessage() {
+    return React.createElement(Text, null, `Failed to search memories`);
+  },
+  renderToolResultMessage(output) {
+    if (!output.success) {
+      return React.createElement(Text, { color: 'error' }, `❌ Failed: ${output.message}`);
+    }
+    if (output.count === 0) {
+      return React.createElement(Text, null, `No memories found matching the query`);
+    }
+    return React.createElement(Text, null, `✅ Found ${output.count} memory result${output.count > 1 ? 's' : ''}`);
+  },
+  async call(input) {
+    console.error(`[XMem Search] Query: "${input.query.substring(0, 50)}..."`)
+    
+    const start = Date.now()
+    
+    try {
+      const result = await xmemClient.search({
+        query: input.query,
+        user_id: 'default_user',
+      })
+      
+      const duration = Date.now() - start
+      console.error(`[XMem Search] ✅ Found ${result.results.length} results in ${duration}ms`)
+      
+      return {
+        data: {
+          success: true,
+          results: result.results.map(r => ({
+            content: r.content,
+            score: r.score,
+          })),
+          count: result.results.length,
+          message: `Found ${result.results.length} memories`,
+        },
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error)
+      console.error(`[XMem Search] ❌ Failed: ${errorMsg}`)
+      
+      return {
+        data: {
+          success: false,
+          results: [],
+          count: 0,
+          message: `Failed to search memories: ${errorMsg}`,
+        },
+      }
+    }
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    if (!output.success) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: `Error: ${output.message}`,
+        is_error: true,
+      }
+    }
+    
+    if (output.count === 0) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: 'No memories found matching this search query.',
+      }
+    }
+    
+    const content = [
+      `Found ${output.count} memory result${output.count > 1 ? 's' : ''}:`,
+      '',
+      ...output.results.map((r, i) => {
+        const prefix = `[${i + 1}]`
+        const score = r.score ? ` (score: ${r.score.toFixed(2)})` : ''
+        return `${prefix}${score} ${r.content}`
+      }),
+    ].join('\n')
+    
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

package/tools/XMemSearchTool/prompt.ts

@@ -0,0 +1,11 @@
+export const XMEM_SEARCH_TOOL_NAME = 'XMemSearch'
+
+export const DESCRIPTION = `Search through all stored memories in XMem to find specific information.
+
+Use this tool when:
+- The user asks "what do you remember about..." or "tell me what you know about..."
+- You need to explore memories without immediately using them in a response
+- Debugging what memories are available
+- The user wants to verify what has been saved
+
+This searches the full memory index and returns all matching entries, useful for memory exploration and verification.`

package/tools/shared/gitOperationTracking.ts

@@ -0,0 +1,277 @@
+/**
+ * Shell-agnostic git operation tracking for usage metrics.
+ *
+ * Detects `git commit`, `git push`, `gh pr create`, `glab mr create`, and
+ * curl-based PR creation in command strings, then increments OTLP counters
+ * and fires analytics events. The regexes operate on raw command text so they
+ * work identically for Bash and PowerShell (both invoke git/gh/glab/curl as
+ * external binaries with the same argv syntax).
+ */
+
+import { getCommitCounter, getPrCounter } from '../../bootstrap/state.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+
+/**
+ * Build a regex that matches `git <subcmd>` while tolerating git's global
+ * options between `git` and the subcommand (e.g. `-c key=val`, `-C path`,
+ * `--git-dir=path`). Common when the model retries with
+ * `git -c commit.gpgsign=false commit` after a signing failure.
+ */
+function gitCmdRe(subcmd: string, suffix = ''): RegExp {
+  return new RegExp(
+    `\\bgit(?:\\s+-[cC]\\s+\\S+|\\s+--\\S+=\\S+)*\\s+${subcmd}\\b${suffix}`,
+  )
+}
+
+const GIT_COMMIT_RE = gitCmdRe('commit')
+const GIT_PUSH_RE = gitCmdRe('push')
+const GIT_CHERRY_PICK_RE = gitCmdRe('cherry-pick')
+const GIT_MERGE_RE = gitCmdRe('merge', '(?!-)')
+const GIT_REBASE_RE = gitCmdRe('rebase')
+
+export type CommitKind = 'committed' | 'amended' | 'cherry-picked'
+export type BranchAction = 'merged' | 'rebased'
+export type PrAction =
+  | 'created'
+  | 'edited'
+  | 'merged'
+  | 'commented'
+  | 'closed'
+  | 'ready'
+
+const GH_PR_ACTIONS: readonly { re: RegExp; action: PrAction; op: string }[] = [
+  { re: /\bgh\s+pr\s+create\b/, action: 'created', op: 'pr_create' },
+  { re: /\bgh\s+pr\s+edit\b/, action: 'edited', op: 'pr_edit' },
+  { re: /\bgh\s+pr\s+merge\b/, action: 'merged', op: 'pr_merge' },
+  { re: /\bgh\s+pr\s+comment\b/, action: 'commented', op: 'pr_comment' },
+  { re: /\bgh\s+pr\s+close\b/, action: 'closed', op: 'pr_close' },
+  { re: /\bgh\s+pr\s+ready\b/, action: 'ready', op: 'pr_ready' },
+]
+
+/**
+ * Parse PR info from a GitHub PR URL.
+ * Returns { prNumber, prUrl, prRepository } or null if not a valid PR URL.
+ */
+function parsePrUrl(
+  url: string,
+): { prNumber: number; prUrl: string; prRepository: string } | null {
+  const match = url.match(/https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/)
+  if (match?.[1] && match?.[2]) {
+    return {
+      prNumber: parseInt(match[2], 10),
+      prUrl: url,
+      prRepository: match[1],
+    }
+  }
+  return null
+}
+
+/** Find a GitHub PR URL embedded anywhere in stdout and parse it. */
+function findPrInStdout(stdout: string): ReturnType<typeof parsePrUrl> {
+  const m = stdout.match(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+/)
+  return m ? parsePrUrl(m[0]) : null
+}
+
+// Exported for testing purposes
+export function parseGitCommitId(stdout: string): string | undefined {
+  // git commit output: [branch abc1234] message
+  // or for root commit: [branch (root-commit) abc1234] message
+  const match = stdout.match(/\[[\w./-]+(?: \(root-commit\))? ([0-9a-f]+)\]/)
+  return match?.[1]
+}
+
+/**
+ * Parse branch name from git push output. Push writes progress to stderr but
+ * the ref update line ("abc..def  branch -> branch", "* [new branch]
+ * branch -> branch", or " + abc...def  branch -> branch (forced update)") is
+ * the signal. Works on either stdout or stderr. Git prefixes each ref line
+ * with a status flag (space, +, -, *, !, =); the char class tolerates any.
+ */
+function parseGitPushBranch(output: string): string | undefined {
+  const match = output.match(
+    /^\s*[+\-*!= ]?\s*(?:\[new branch\]|\S+\.\.+\S+)\s+\S+\s*->\s*(\S+)/m,
+  )
+  return match?.[1]
+}
+
+/**
+ * gh pr merge/close/ready print "✓ <Verb> pull request owner/repo#1234" with
+ * no URL. Extract the PR number from the text.
+ */
+function parsePrNumberFromText(stdout: string): number | undefined {
+  const match = stdout.match(/[Pp]ull request (?:\S+#)?#?(\d+)/)
+  return match?.[1] ? parseInt(match[1], 10) : undefined
+}
+
+/**
+ * Extract target ref from `git merge <ref>` / `git rebase <ref>` command.
+ * Skips flags and keywords — first non-flag argument is the ref.
+ */
+function parseRefFromCommand(
+  command: string,
+  verb: string,
+): string | undefined {
+  const after = command.split(gitCmdRe(verb))[1]
+  if (!after) return undefined
+  for (const t of after.trim().split(/\s+/)) {
+    if (/^[&|;><]/.test(t)) break
+    if (t.startsWith('-')) continue
+    return t
+  }
+  return undefined
+}
+
+/**
+ * Scan bash command + output for git operations worth surfacing in the
+ * collapsed tool-use summary ("committed a1b2c3, created PR #42, ran 3 bash
+ * commands"). Checks the command to avoid matching SHAs/URLs that merely
+ * appear in unrelated output (e.g. `git log`).
+ *
+ * Pass stdout+stderr concatenated — git push writes the ref update to stderr.
+ */
+export function detectGitOperation(
+  command: string,
+  output: string,
+): {
+  commit?: { sha: string; kind: CommitKind }
+  push?: { branch: string }
+  branch?: { ref: string; action: BranchAction }
+  pr?: { number: number; url?: string; action: PrAction }
+} {
+  const result: ReturnType<typeof detectGitOperation> = {}
+  // commit and cherry-pick both produce "[branch sha] msg" output
+  const isCherryPick = GIT_CHERRY_PICK_RE.test(command)
+  if (GIT_COMMIT_RE.test(command) || isCherryPick) {
+    const sha = parseGitCommitId(output)
+    if (sha) {
+      result.commit = {
+        sha: sha.slice(0, 6),
+        kind: isCherryPick
+          ? 'cherry-picked'
+          : /--amend\b/.test(command)
+            ? 'amended'
+            : 'committed',
+      }
+    }
+  }
+  if (GIT_PUSH_RE.test(command)) {
+    const branch = parseGitPushBranch(output)
+    if (branch) result.push = { branch }
+  }
+  if (
+    GIT_MERGE_RE.test(command) &&
+    /(Fast-forward|Merge made by)/.test(output)
+  ) {
+    const ref = parseRefFromCommand(command, 'merge')
+    if (ref) result.branch = { ref, action: 'merged' }
+  }
+  if (GIT_REBASE_RE.test(command) && /Successfully rebased/.test(output)) {
+    const ref = parseRefFromCommand(command, 'rebase')
+    if (ref) result.branch = { ref, action: 'rebased' }
+  }
+  const prAction = GH_PR_ACTIONS.find(a => a.re.test(command))?.action
+  if (prAction) {
+    const pr = findPrInStdout(output)
+    if (pr) {
+      result.pr = { number: pr.prNumber, url: pr.prUrl, action: prAction }
+    } else {
+      const num = parsePrNumberFromText(output)
+      if (num) result.pr = { number: num, action: prAction }
+    }
+  }
+  return result
+}
+
+// Exported for testing purposes
+export function trackGitOperations(
+  command: string,
+  exitCode: number,
+  stdout?: string,
+): void {
+  const success = exitCode === 0
+  if (!success) {
+    return
+  }
+
+  if (GIT_COMMIT_RE.test(command)) {
+    logEvent('tengu_git_operation', {
+      operation:
+        'commit' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    if (command.match(/--amend\b/)) {
+      logEvent('tengu_git_operation', {
+        operation:
+          'commit_amend' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+    }
+    getCommitCounter()?.add(1)
+  }
+  if (GIT_PUSH_RE.test(command)) {
+    logEvent('tengu_git_operation', {
+      operation:
+        'push' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+  }
+  const prHit = GH_PR_ACTIONS.find(a => a.re.test(command))
+  if (prHit) {
+    logEvent('tengu_git_operation', {
+      operation:
+        prHit.op as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+  }
+  if (prHit?.action === 'created') {
+    getPrCounter()?.add(1)
+    // Auto-link session to PR if we can extract PR URL from stdout
+    if (stdout) {
+      const prInfo = findPrInStdout(stdout)
+      if (prInfo) {
+        // Import is done dynamically to avoid circular dependency
+        void import('../../utils/sessionStorage.js').then(
+          ({ linkSessionToPR }) => {
+            void import('../../bootstrap/state.js').then(({ getSessionId }) => {
+              const sessionId = getSessionId()
+              if (sessionId) {
+                void linkSessionToPR(
+                  sessionId as `${string}-${string}-${string}-${string}-${string}`,
+                  prInfo.prNumber,
+                  prInfo.prUrl,
+                  prInfo.prRepository,
+                )
+              }
+            })
+          },
+        )
+      }
+    }
+  }
+  if (command.match(/\bglab\s+mr\s+create\b/)) {
+    logEvent('tengu_git_operation', {
+      operation:
+        'pr_create' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    getPrCounter()?.add(1)
+  }
+  // Detect PR creation via curl to REST APIs (Bitbucket, GitHub API, GitLab API)
+  // Check for POST method and PR endpoint separately to handle any argument order
+  // Also detect implicit POST when -d is used (curl defaults to POST with data)
+  const isCurlPost =
+    command.match(/\bcurl\b/) &&
+    (command.match(/-X\s*POST\b/i) ||
+      command.match(/--request\s*=?\s*POST\b/i) ||
+      command.match(/\s-d\s/))
+  // Match PR endpoints in URLs, but not sub-resources like /pulls/123/comments
+  // Require https?:// prefix to avoid matching text in POST body or other params
+  const isPrEndpoint = command.match(
+    /https?:\/\/[^\s'"]*\/(pulls|pull-requests|merge[-_]requests)(?!\/\d)/i,
+  )
+  if (isCurlPost && isPrEndpoint) {
+    logEvent('tengu_git_operation', {
+      operation:
+        'pr_create' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    getPrCounter()?.add(1)
+  }
+}