@xortex/xcode 3.0.8 → 3.1.0

package/outputStyles/loadOutputStylesDir.ts

@@ -0,0 +1,98 @@
+import memoize from 'lodash-es/memoize.js'
+import { basename } from 'path'
+import type { OutputStyleConfig } from '../constants/outputStyles.js'
+import { logForDebugging } from '../utils/debug.js'
+import { coerceDescriptionToString } from '../utils/frontmatterParser.js'
+import { logError } from '../utils/log.js'
+import {
+  extractDescriptionFromMarkdown,
+  loadMarkdownFilesForSubdir,
+} from '../utils/markdownConfigLoader.js'
+import { clearPluginOutputStyleCache } from '../utils/plugins/loadPluginOutputStyles.js'
+
+/**
+ * Loads markdown files from .claude/output-styles directories throughout the project
+ * and from ~/.claude/output-styles directory and converts them to output styles.
+ *
+ * Each filename becomes a style name, and the file content becomes the style prompt.
+ * The frontmatter provides name and description.
+ *
+ * Structure:
+ * - Project .claude/output-styles/*.md -> project styles
+ * - User ~/.claude/output-styles/*.md -> user styles (overridden by project styles)
+ *
+ * @param cwd Current working directory for project directory traversal
+ */
+export const getOutputStyleDirStyles = memoize(
+  async (cwd: string): Promise<OutputStyleConfig[]> => {
+    try {
+      const markdownFiles = await loadMarkdownFilesForSubdir(
+        'output-styles',
+        cwd,
+      )
+
+      const styles = markdownFiles
+        .map(({ filePath, frontmatter, content, source }) => {
+          try {
+            const fileName = basename(filePath)
+            const styleName = fileName.replace(/\.md$/, '')
+
+            // Get style configuration from frontmatter
+            const name = (frontmatter['name'] || styleName) as string
+            const description =
+              coerceDescriptionToString(
+                frontmatter['description'],
+                styleName,
+              ) ??
+              extractDescriptionFromMarkdown(
+                content,
+                `Custom ${styleName} output style`,
+              )
+
+            // Parse keep-coding-instructions flag (supports both boolean and string values)
+            const keepCodingInstructionsRaw =
+              frontmatter['keep-coding-instructions']
+            const keepCodingInstructions =
+              keepCodingInstructionsRaw === true ||
+              keepCodingInstructionsRaw === 'true'
+                ? true
+                : keepCodingInstructionsRaw === false ||
+                    keepCodingInstructionsRaw === 'false'
+                  ? false
+                  : undefined
+
+            // Warn if force-for-plugin is set on non-plugin output style
+            if (frontmatter['force-for-plugin'] !== undefined) {
+              logForDebugging(
+                `Output style "${name}" has force-for-plugin set, but this option only applies to plugin output styles. Ignoring.`,
+                { level: 'warn' },
+              )
+            }
+
+            return {
+              name,
+              description,
+              prompt: content.trim(),
+              source,
+              keepCodingInstructions,
+            }
+          } catch (error) {
+            logError(error)
+            return null
+          }
+        })
+        .filter(style => style !== null)
+
+      return styles
+    } catch (error) {
+      logError(error)
+      return []
+    }
+  },
+)
+
+export function clearOutputStyleCaches(): void {
+  getOutputStyleDirStyles.cache?.clear?.()
+  loadMarkdownFilesForSubdir.cache?.clear?.()
+  clearPluginOutputStyleCache()
+}

package/package.json

@@ -1,55 +1,16 @@
 {
   "name": "@xortex/xcode",
-  "version": "3.0.8",
+  "version": "3.1.0",
   "description": "XCode - AI-powered coding assistant with XMem long-term memory. Supports Claude, Gemini, Kimi, DeepSeek via OpenRouter.",
   "main": "main.tsx",
   "bin": {
     "xcode": "./bin/xcode"
   },
   "scripts": {
-    "start": "bun run ./entrypoints/cli.tsx || tsx ./entrypoints/cli.tsx",
+    "start": "bun run ./entrypoints/cli.tsx",
+    "postinstall": "node scripts/postinstall.js",
     "install-global": "npm install -g ."
   },
-  "files": [
-    "bin/",
-    "entrypoints/",
-    "main.tsx",
-    "macro.ts",
-    "bun-bundle-hook.js",
-    "bun-bundle-shim.ts",
-    "tsconfig.json",
-    "src/",
-    "constants/",
-    "utils/",
-    "services/",
-    "tools/",
-    "commands/",
-    "hooks/",
-    "ink/",
-    "keybindings/",
-    "tasks/",
-    "types/",
-    "state/",
-    "components/",
-    "skills/",
-    "migrations/",
-    "buddy/",
-    "bridge/",
-    "remote/",
-    "assistant/",
-    "cli/",
-    "context.ts",
-    "commands.ts",
-    "cost-tracker.ts",
-    "history.ts",
-    "Task.ts",
-    "Tool.ts",
-    "QueryEngine.ts",
-    "query.ts",
-    "*.js",
-    "README.md",
-    "LICENSE"
-  ],
   "keywords": [
     "ai",
     "coding",

package/plugins/builtinPlugins.ts

@@ -0,0 +1,159 @@
+/**
+ * Built-in Plugin Registry
+ *
+ * Manages built-in plugins that ship with the CLI and can be enabled/disabled
+ * by users via the /plugin UI.
+ *
+ * Built-in plugins differ from bundled skills (src/skills/bundled/) in that:
+ * - They appear in the /plugin UI under a "Built-in" section
+ * - Users can enable/disable them (persisted to user settings)
+ * - They can provide multiple components (skills, hooks, MCP servers)
+ *
+ * Plugin IDs use the format `{name}@builtin` to distinguish them from
+ * marketplace plugins (`{name}@{marketplace}`).
+ */
+
+import type { Command } from '../commands.js'
+import type { BundledSkillDefinition } from '../skills/bundledSkills.js'
+import type { BuiltinPluginDefinition, LoadedPlugin } from '../types/plugin.js'
+import { getSettings_DEPRECATED } from '../utils/settings/settings.js'
+
+const BUILTIN_PLUGINS: Map<string, BuiltinPluginDefinition> = new Map()
+
+export const BUILTIN_MARKETPLACE_NAME = 'builtin'
+
+/**
+ * Register a built-in plugin. Call this from initBuiltinPlugins() at startup.
+ */
+export function registerBuiltinPlugin(
+  definition: BuiltinPluginDefinition,
+): void {
+  BUILTIN_PLUGINS.set(definition.name, definition)
+}
+
+/**
+ * Check if a plugin ID represents a built-in plugin (ends with @builtin).
+ */
+export function isBuiltinPluginId(pluginId: string): boolean {
+  return pluginId.endsWith(`@${BUILTIN_MARKETPLACE_NAME}`)
+}
+
+/**
+ * Get a specific built-in plugin definition by name.
+ * Useful for the /plugin UI to show the skills/hooks/MCP list without
+ * a marketplace lookup.
+ */
+export function getBuiltinPluginDefinition(
+  name: string,
+): BuiltinPluginDefinition | undefined {
+  return BUILTIN_PLUGINS.get(name)
+}
+
+/**
+ * Get all registered built-in plugins as LoadedPlugin objects, split into
+ * enabled/disabled based on user settings (with defaultEnabled as fallback).
+ * Plugins whose isAvailable() returns false are omitted entirely.
+ */
+export function getBuiltinPlugins(): {
+  enabled: LoadedPlugin[]
+  disabled: LoadedPlugin[]
+} {
+  const settings = getSettings_DEPRECATED()
+  const enabled: LoadedPlugin[] = []
+  const disabled: LoadedPlugin[] = []
+
+  for (const [name, definition] of BUILTIN_PLUGINS) {
+    if (definition.isAvailable && !definition.isAvailable()) {
+      continue
+    }
+
+    const pluginId = `${name}@${BUILTIN_MARKETPLACE_NAME}`
+    const userSetting = settings?.enabledPlugins?.[pluginId]
+    // Enabled state: user preference > plugin default > true
+    const isEnabled =
+      userSetting !== undefined
+        ? userSetting === true
+        : (definition.defaultEnabled ?? true)
+
+    const plugin: LoadedPlugin = {
+      name,
+      manifest: {
+        name,
+        description: definition.description,
+        version: definition.version,
+      },
+      path: BUILTIN_MARKETPLACE_NAME, // sentinel — no filesystem path
+      source: pluginId,
+      repository: pluginId,
+      enabled: isEnabled,
+      isBuiltin: true,
+      hooksConfig: definition.hooks,
+      mcpServers: definition.mcpServers,
+    }
+
+    if (isEnabled) {
+      enabled.push(plugin)
+    } else {
+      disabled.push(plugin)
+    }
+  }
+
+  return { enabled, disabled }
+}
+
+/**
+ * Get skills from enabled built-in plugins as Command objects.
+ * Skills from disabled plugins are not returned.
+ */
+export function getBuiltinPluginSkillCommands(): Command[] {
+  const { enabled } = getBuiltinPlugins()
+  const commands: Command[] = []
+
+  for (const plugin of enabled) {
+    const definition = BUILTIN_PLUGINS.get(plugin.name)
+    if (!definition?.skills) continue
+    for (const skill of definition.skills) {
+      commands.push(skillDefinitionToCommand(skill))
+    }
+  }
+
+  return commands
+}
+
+/**
+ * Clear built-in plugins registry (for testing).
+ */
+export function clearBuiltinPlugins(): void {
+  BUILTIN_PLUGINS.clear()
+}
+
+// --
+
+function skillDefinitionToCommand(definition: BundledSkillDefinition): Command {
+  return {
+    type: 'prompt',
+    name: definition.name,
+    description: definition.description,
+    hasUserSpecifiedDescription: true,
+    allowedTools: definition.allowedTools ?? [],
+    argumentHint: definition.argumentHint,
+    whenToUse: definition.whenToUse,
+    model: definition.model,
+    disableModelInvocation: definition.disableModelInvocation ?? false,
+    userInvocable: definition.userInvocable ?? true,
+    contentLength: 0,
+    // 'bundled' not 'builtin' — 'builtin' in Command.source means hardcoded
+    // slash commands (/help, /clear). Using 'bundled' keeps these skills in
+    // the Skill tool's listing, analytics name logging, and prompt-truncation
+    // exemption. The user-toggleable aspect is tracked on LoadedPlugin.isBuiltin.
+    source: 'bundled',
+    loadedFrom: 'bundled',
+    hooks: definition.hooks,
+    context: definition.context,
+    agent: definition.agent,
+    isEnabled: definition.isEnabled ?? (() => true),
+    isHidden: !(definition.userInvocable ?? true),
+    progressMessage: 'running',
+    getPromptForCommand: definition.getPromptForCommand,
+  }
+}

package/plugins/bundled/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Built-in Plugin Initialization
+ *
+ * Initializes built-in plugins that ship with the CLI and appear in the
+ * /plugin UI for users to enable/disable.
+ *
+ * Not all bundled features should be built-in plugins — use this for
+ * features that users should be able to explicitly enable/disable. For
+ * features with complex setup or automatic-enabling logic (e.g.
+ * claude-in-chrome), use src/skills/bundled/ instead.
+ *
+ * To add a new built-in plugin:
+ * 1. Import registerBuiltinPlugin from '../builtinPlugins.js'
+ * 2. Call registerBuiltinPlugin() with the plugin definition here
+ */
+
+/**
+ * Initialize built-in plugins. Called during CLI startup.
+ */
+export function initBuiltinPlugins(): void {
+  // No built-in plugins registered yet — this is the scaffolding for
+  // migrating bundled skills that should be user-toggleable.
+}

package/projectOnboardingState.ts

@@ -0,0 +1,83 @@
+import memoize from 'lodash-es/memoize.js'
+import { join } from 'path'
+import {
+  getCurrentProjectConfig,
+  saveCurrentProjectConfig,
+} from './utils/config.js'
+import { getCwd } from './utils/cwd.js'
+import { isDirEmpty } from './utils/file.js'
+import { getFsImplementation } from './utils/fsOperations.js'
+
+export type Step = {
+  key: string
+  text: string
+  isComplete: boolean
+  isCompletable: boolean
+  isEnabled: boolean
+}
+
+export function getSteps(): Step[] {
+  const hasClaudeMd = getFsImplementation().existsSync(
+    join(getCwd(), 'CLAUDE.md'),
+  )
+  const isWorkspaceDirEmpty = isDirEmpty(getCwd())
+
+  return [
+    {
+      key: 'workspace',
+      text: 'Ask Claude to create a new app or clone a repository',
+      isComplete: false,
+      isCompletable: true,
+      isEnabled: isWorkspaceDirEmpty,
+    },
+    {
+      key: 'claudemd',
+      text: 'Run /init to create a CLAUDE.md file with instructions for Claude',
+      isComplete: hasClaudeMd,
+      isCompletable: true,
+      isEnabled: !isWorkspaceDirEmpty,
+    },
+  ]
+}
+
+export function isProjectOnboardingComplete(): boolean {
+  return getSteps()
+    .filter(({ isCompletable, isEnabled }) => isCompletable && isEnabled)
+    .every(({ isComplete }) => isComplete)
+}
+
+export function maybeMarkProjectOnboardingComplete(): void {
+  // Short-circuit on cached config — isProjectOnboardingComplete() hits
+  // the filesystem, and REPL.tsx calls this on every prompt submit.
+  if (getCurrentProjectConfig().hasCompletedProjectOnboarding) {
+    return
+  }
+  if (isProjectOnboardingComplete()) {
+    saveCurrentProjectConfig(current => ({
+      ...current,
+      hasCompletedProjectOnboarding: true,
+    }))
+  }
+}
+
+export const shouldShowProjectOnboarding = memoize((): boolean => {
+  const projectConfig = getCurrentProjectConfig()
+  // Short-circuit on cached config before isProjectOnboardingComplete()
+  // hits the filesystem — this runs during first render.
+  if (
+    projectConfig.hasCompletedProjectOnboarding ||
+    projectConfig.projectOnboardingSeenCount >= 4 ||
+    process.env.IS_DEMO
+  ) {
+    return false
+  }
+
+  return !isProjectOnboardingComplete()
+})
+
+export function incrementProjectOnboardingSeenCount(): void {
+  saveCurrentProjectConfig(current => ({
+    ...current,
+    projectOnboardingSeenCount: current.projectOnboardingSeenCount + 1,
+  }))
+}

package/query/config.ts

@@ -0,0 +1,46 @@
+import { getSessionId } from '../bootstrap/state.js'
+import { checkStatsigFeatureGate_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import type { SessionId } from '../types/ids.js'
+import { isEnvTruthy } from '../utils/envUtils.js'
+
+// -- config
+
+// Immutable values snapshotted once at query() entry. Separating these from
+// the per-iteration State struct and the mutable ToolUseContext makes future
+// step() extraction tractable — a pure reducer can take (state, event, config)
+// where config is plain data.
+//
+// Intentionally excludes feature() gates — those are tree-shaking boundaries
+// and must stay inline at the guarded blocks for dead-code elimination.
+export type QueryConfig = {
+  sessionId: SessionId
+
+  // Runtime gates (env/statsig). NOT feature() gates — see above.
+  gates: {
+    // Statsig — CACHED_MAY_BE_STALE already admits staleness, so snapshotting
+    // once per query() call stays within the existing contract.
+    streamingToolExecution: boolean
+    emitToolUseSummaries: boolean
+    isAnt: boolean
+    fastModeEnabled: boolean
+  }
+}
+
+export function buildQueryConfig(): QueryConfig {
+  return {
+    sessionId: getSessionId(),
+    gates: {
+      streamingToolExecution: checkStatsigFeatureGate_CACHED_MAY_BE_STALE(
+        'tengu_streaming_tool_execution2',
+      ),
+      emitToolUseSummaries: isEnvTruthy(
+        process.env.CLAUDE_CODE_EMIT_TOOL_USE_SUMMARIES,
+      ),
+      isAnt: process.env.USER_TYPE === 'ant',
+      // Inlined from fastMode.ts to avoid pulling its heavy module graph
+      // (axios, settings, auth, model, oauth, config) into test shards that
+      // didn't previously load it — changes init order and breaks unrelated tests.
+      fastModeEnabled: !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_FAST_MODE),
+    },
+  }
+}

package/query/deps.ts

@@ -0,0 +1,40 @@
+import { randomUUID } from 'crypto'
+import { queryModelWithStreaming } from '../services/api/gemini.js'
+import { autoCompactIfNeeded } from '../services/compact/autoCompact.js'
+import { microcompactMessages } from '../services/compact/microCompact.js'
+
+// -- deps
+
+// I/O dependencies for query(). Passing a `deps` override into QueryParams
+// lets tests inject fakes directly instead of spyOn-per-module — the most
+// common mocks (callModel, autocompact) are each spied in 6-8 test files
+// today with module-import-and-spy boilerplate.
+//
+// Using `typeof fn` keeps signatures in sync with the real implementations
+// automatically. This file imports the real functions for both typing and
+// the production factory — tests that import this file for typing are
+// already importing query.ts (which imports everything), so there's no
+// new module-graph cost.
+//
+// Scope is intentionally narrow (4 deps) to prove the pattern. Followup
+// PRs can add runTools, handleStopHooks, logEvent, queue ops, etc.
+export type QueryDeps = {
+  // -- model
+  callModel: typeof queryModelWithStreaming
+
+  // -- compaction
+  microcompact: typeof microcompactMessages
+  autocompact: typeof autoCompactIfNeeded
+
+  // -- platform
+  uuid: () => string
+}
+
+export function productionDeps(): QueryDeps {
+  return {
+    callModel: queryModelWithStreaming,
+    microcompact: microcompactMessages,
+    autocompact: autoCompactIfNeeded,
+    uuid: randomUUID,
+  }
+}