effort.tsx

import { c as _c } from "react/compiler-runtime";
import * as React from 'react';
import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
import { useAppState, useSetAppState } from '../../state/AppState.js';
import type { LocalJSXCommandOnDone } from '../../types/command.js';
import { type EffortValue, getDisplayedEffortLevel, getEffortEnvOverride, getEffortValueDescription, isEffortLevel, toPersistableEffort } from '../../utils/effort.js';
import { updateSettingsForSource } from '../../utils/settings/settings.js';
const COMMON_HELP_ARGS = ['help', '-h', '--help'];
type EffortCommandResult = {
  message: string;
  effortUpdate?: {
    value: EffortValue | undefined;
  };
};
function setEffortValue(effortValue: EffortValue): EffortCommandResult {
  const persistable = toPersistableEffort(effortValue);
  if (persistable !== undefined) {
    const result = updateSettingsForSource('userSettings', {
      effortLevel: persistable
    });
    if (result.error) {
      return {
        message: `Failed to set effort level: ${result.error.message}`
      };
    }
  }
  logEvent('tengu_effort_command', {
    effort: effortValue as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
  });

  // Env var wins at resolveAppliedEffort time. Only flag it when it actually
  // conflicts — if env matches what the user just asked for, the outcome is
  // the same, so "Set effort to X" is true and the note is noise.
  const envOverride = getEffortEnvOverride();
  if (envOverride !== undefined && envOverride !== effortValue) {
    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
    if (persistable === undefined) {
      return {
        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,
        effortUpdate: {
          value: effortValue
        }
      };
    }
    return {
      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session — clear it and ${effortValue} takes over`,
      effortUpdate: {
        value: effortValue
      }
    };
  }
  const description = getEffortValueDescription(effortValue);
  const suffix = persistable !== undefined ? '' : ' (this session only)';
  return {
    message: `Set effort level to ${effortValue}${suffix}: ${description}`,
    effortUpdate: {
      value: effortValue
    }
  };
}
export function showCurrentEffort(appStateEffort: EffortValue | undefined, model: string): EffortCommandResult {
  const envOverride = getEffortEnvOverride();
  const effectiveValue = envOverride === null ? undefined : envOverride ?? appStateEffort;
  if (effectiveValue === undefined) {
    const level = getDisplayedEffortLevel(model, appStateEffort);
    return {
      message: `Effort level: auto (currently ${level})`
    };
  }
  const description = getEffortValueDescription(effectiveValue);
  return {
    message: `Current effort level: ${effectiveValue} (${description})`
  };
}
function unsetEffortLevel(): EffortCommandResult {
  const result = updateSettingsForSource('userSettings', {
    effortLevel: undefined
  });
  if (result.error) {
    return {
      message: `Failed to set effort level: ${result.error.message}`
    };
  }
  logEvent('tengu_effort_command', {
    effort: 'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
  });
  // env=auto/unset (null) matches what /effort auto asks for, so only warn
  // when env is pinning a specific level that will keep overriding.
  const envOverride = getEffortEnvOverride();
  if (envOverride !== undefined && envOverride !== null) {
    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
    return {
      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,
      effortUpdate: {
        value: undefined
      }
    };
  }
  return {
    message: 'Effort level set to auto',
    effortUpdate: {
      value: undefined
    }
  };
}
export function executeEffort(args: string): EffortCommandResult {
  const normalized = args.toLowerCase();
  if (normalized === 'auto' || normalized === 'unset') {
    return unsetEffortLevel();
  }
  if (!isEffortLevel(normalized)) {
    return {
      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`
    };
  }
  return setEffortValue(normalized);
}
function ShowCurrentEffort(t0) {
  const {
    onDone
  } = t0;
  const effortValue = useAppState(_temp);
  const model = useMainLoopModel();
  const {
    message
  } = showCurrentEffort(effortValue, model);
  onDone(message);
  return null;
}
function _temp(s) {
  return s.effortValue;
}
function ApplyEffortAndClose(t0) {
  const $ = _c(6);
  const {
    result,
    onDone
  } = t0;
  const setAppState = useSetAppState();
  const {
    effortUpdate,
    message
  } = result;
  let t1;
  let t2;
  if ($[0] !== effortUpdate || $[1] !== message || $[2] !== onDone || $[3] !== setAppState) {
    t1 = () => {
      if (effortUpdate) {
        setAppState(prev => ({
          ...prev,
          effortValue: effortUpdate.value
        }));
      }
      onDone(message);
    };
    t2 = [setAppState, effortUpdate, message, onDone];
    $[0] = effortUpdate;
    $[1] = message;
    $[2] = onDone;
    $[3] = setAppState;
    $[4] = t1;
    $[5] = t2;
  } else {
    t1 = $[4];
    t2 = $[5];
  }
  React.useEffect(t1, t2);
  return null;
}
export async function call(onDone: LocalJSXCommandOnDone, _context: unknown, args?: string): Promise<React.ReactNode> {
  args = args?.trim() || '';
  if (COMMON_HELP_ARGS.includes(args)) {
    onDone('Usage: /effort [low|medium|high|max|auto]\n\nEffort levels:\n- low: Quick, straightforward implementation\n- medium: Balanced approach with standard testing\n- high: Comprehensive implementation with extensive testing\n- max: Maximum capability with deepest reasoning (Opus 4.6 only)\n- auto: Use the default effort level for your model');
    return;
  }
  if (!args || args === 'current' || args === 'status') {
    return <ShowCurrentEffort onDone={onDone} />;
  }
  const result = executeEffort(args);
  return <ApplyEffortAndClose result={result} onDone={onDone} />;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMainLoopModel","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useAppState","useSetAppState","LocalJSXCommandOnDone","EffortValue","getDisplayedEffortLevel","getEffortEnvOverride","getEffortValueDescription","isEffortLevel","toPersistableEffort","updateSettingsForSource","COMMON_HELP_ARGS","EffortCommandResult","message","effortUpdate","value","setEffortValue","effortValue","persistable","undefined","result","effortLevel","error","effort","envOverride","envRaw","process","env","CLAUDE_CODE_EFFORT_LEVEL","description","suffix","showCurrentEffort","appStateEffort","model","effectiveValue","level","unsetEffortLevel","executeEffort","args","normalized","toLowerCase","ShowCurrentEffort","t0","onDone","_temp","s","ApplyEffortAndClose","$","_c","setAppState","t1","t2","prev","useEffect","call","_context","Promise","ReactNode","trim","includes"],"sources":["effort.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport {\n  type EffortValue,\n  getDisplayedEffortLevel,\n  getEffortEnvOverride,\n  getEffortValueDescription,\n  isEffortLevel,\n  toPersistableEffort,\n} from '../../utils/effort.js'\nimport { updateSettingsForSource } from '../../utils/settings/settings.js'\n\nconst COMMON_HELP_ARGS = ['help', '-h', '--help']\n\ntype EffortCommandResult = {\n  message: string\n  effortUpdate?: { value: EffortValue | undefined }\n}\n\nfunction setEffortValue(effortValue: EffortValue): EffortCommandResult {\n  const persistable = toPersistableEffort(effortValue)\n  if (persistable !== undefined) {\n    const result = updateSettingsForSource('userSettings', {\n      effortLevel: persistable,\n    })\n    if (result.error) {\n      return {\n        message: `Failed to set effort level: ${result.error.message}`,\n      }\n    }\n  }\n  logEvent('tengu_effort_command', {\n    effort:\n      effortValue as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n\n  // Env var wins at resolveAppliedEffort time. Only flag it when it actually\n  // conflicts — if env matches what the user just asked for, the outcome is\n  // the same, so \"Set effort to X\" is true and the note is noise.\n  const envOverride = getEffortEnvOverride()\n  if (envOverride !== undefined && envOverride !== effortValue) {\n    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL\n    if (persistable === undefined) {\n      return {\n        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,\n        effortUpdate: { value: effortValue },\n      }\n    }\n    return {\n      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session — clear it and ${effortValue} takes over`,\n      effortUpdate: { value: effortValue },\n    }\n  }\n\n  const description = getEffortValueDescription(effortValue)\n  const suffix = persistable !== undefined ? '' : ' (this session only)'\n  return {\n    message: `Set effort level to ${effortValue}${suffix}: ${description}`,\n    effortUpdate: { value: effortValue },\n  }\n}\n\nexport function showCurrentEffort(\n  appStateEffort: EffortValue | undefined,\n  model: string,\n): EffortCommandResult {\n  const envOverride = getEffortEnvOverride()\n  const effectiveValue =\n    envOverride === null ? undefined : (envOverride ?? appStateEffort)\n  if (effectiveValue === undefined) {\n    const level = getDisplayedEffortLevel(model, appStateEffort)\n    return { message: `Effort level: auto (currently ${level})` }\n  }\n  const description = getEffortValueDescription(effectiveValue)\n  return {\n    message: `Current effort level: ${effectiveValue} (${description})`,\n  }\n}\n\nfunction unsetEffortLevel(): EffortCommandResult {\n  const result = updateSettingsForSource('userSettings', {\n    effortLevel: undefined,\n  })\n  if (result.error) {\n    return {\n      message: `Failed to set effort level: ${result.error.message}`,\n    }\n  }\n  logEvent('tengu_effort_command', {\n    effort:\n      'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  // env=auto/unset (null) matches what /effort auto asks for, so only warn\n  // when env is pinning a specific level that will keep overriding.\n  const envOverride = getEffortEnvOverride()\n  if (envOverride !== undefined && envOverride !== null) {\n    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL\n    return {\n      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,\n      effortUpdate: { value: undefined },\n    }\n  }\n  return {\n    message: 'Effort level set to auto',\n    effortUpdate: { value: undefined },\n  }\n}\n\nexport function executeEffort(args: string): EffortCommandResult {\n  const normalized = args.toLowerCase()\n  if (normalized === 'auto' || normalized === 'unset') {\n    return unsetEffortLevel()\n  }\n\n  if (!isEffortLevel(normalized)) {\n    return {\n      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`,\n    }\n  }\n\n  return setEffortValue(normalized)\n}\n\nfunction ShowCurrentEffort({\n  onDone,\n}: {\n  onDone: (result: string) => void\n}): React.ReactNode {\n  const effortValue = useAppState(s => s.effortValue)\n  const model = useMainLoopModel()\n  const { message } = showCurrentEffort(effortValue, model)\n  onDone(message)\n  return null\n}\n\nfunction ApplyEffortAndClose({\n  result,\n  onDone,\n}: {\n  result: EffortCommandResult\n  onDone: (result: string) => void\n}): React.ReactNode {\n  const setAppState = useSetAppState()\n  const { effortUpdate, message } = result\n  React.useEffect(() => {\n    if (effortUpdate) {\n      setAppState(prev => ({\n        ...prev,\n        effortValue: effortUpdate.value,\n      }))\n    }\n    onDone(message)\n  }, [setAppState, effortUpdate, message, onDone])\n  return null\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  _context: unknown,\n  args?: string,\n): Promise<React.ReactNode> {\n  args = args?.trim() || ''\n\n  if (COMMON_HELP_ARGS.includes(args)) {\n    onDone(\n      'Usage: /effort [low|medium|high|max|auto]\\n\\nEffort levels:\\n- low: Quick, straightforward implementation\\n- medium: Balanced approach with standard testing\\n- high: Comprehensive implementation with extensive testing\\n- max: Maximum capability with deepest reasoning (Opus 4.6 only)\\n- auto: Use the default effort level for your model',\n    )\n    return\n  }\n\n  if (!args || args === 'current' || args === 'status') {\n    return <ShowCurrentEffort onDone={onDone} />\n  }\n\n  const result = executeEffort(args)\n  return <ApplyEffortAndClose result={result} onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}