acdev 1.0.8 → 1.0.10

package/src/config.js

@@ -6,20 +6,15 @@ import { checkGhAuth, githubTokenFromEnv, originRemoteInfo } from './gh-auth.js'
 import { normalizeJiraBaseUrl } from './jira.js';
 import {
   DEFAULT_MODEL,
-  DEFAULT_OPENROUTER_MODEL,
-  LLM_PROVIDERS,
   NO_MODEL,
   isValidModelId,
   isNoModel,
-  isValidLlmProvider,
-  defaultModelForProvider,
-  isModelIdForProvider,
+  isClaudeCatalogId,
   curatedModelOptions,
 } from './models.js';
-import { checkOpenRouterAuth } from './openrouter-auth.js';
 import { dataDir } from './paths.js';
 
-export { DEFAULT_MODEL, DEFAULT_OPENROUTER_MODEL, CLAUDE_MODEL_OPTIONS, MODEL_OPTIONS, OPENROUTER_MODEL_OPTIONS, LLM_PROVIDERS, NO_MODEL } from './models.js';
+export { DEFAULT_MODEL, CLAUDE_MODEL_OPTIONS, MODEL_OPTIONS, NO_MODEL } from './models.js';
 
 /** Tool names the agent may be granted via config. */
 export const KNOWN_TOOLS = ['Read', 'Glob', 'Grep', 'Edit', 'Write', 'Bash'];
@@ -69,10 +64,7 @@ const DEFAULTS = {
   maxAgentTurns: 30,
   allowedTools: [...KNOWN_TOOLS],
   agentTimeoutMs: 900_000,
-  llmProvider: /** @type {'claude' | 'openrouter'} */ ('claude'),
   model: DEFAULT_MODEL,
-  /** Last valid model selection per LLM provider (for restore on provider switch). */
-  lastModelsByProvider: /** @type {Record<string, string>} */ ({}),
   ticketSource: /** @type {'github' | 'jira'} */ ('github'),
   jiraBaseUrl: '',
   /** PR body phrase for Jira tickets, e.g. "Relates to PROJ-123". */
@@ -82,76 +74,29 @@ const DEFAULTS = {
 };
 
 /**
+ * Migrate legacy OpenRouter model ids to a Claude model.
  * @param {unknown} raw
- * @returns {Record<string, string>}
- */
-function normalizeLastModelsByProvider(raw) {
-  /** @type {Record<string, string>} */
-  const out = {};
-  if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
-    return out;
-  }
-  for (const provider of LLM_PROVIDERS) {
-    const value = /** @type {Record<string, unknown>} */ (raw)[provider];
-    if (typeof value !== 'string' || isNoModel(value) || !isValidModelId(value)) {
-      continue;
-    }
-    const id = value.trim();
-    if (isModelIdForProvider(id, provider)) {
-      out[provider] = id;
-    }
-  }
-  return out;
-}
-
-/**
- * @param {object} config
- * @param {'claude' | 'openrouter'} provider
- * @param {string} model
- */
-function rememberModelForProvider(config, provider, model) {
-  if (!isValidLlmProvider(provider)) return;
-  if (isNoModel(model) || !isValidModelId(model)) return;
-  const id = String(model).trim();
-  if (!isModelIdForProvider(id, provider)) return;
-  if (
-    !config.lastModelsByProvider ||
-    typeof config.lastModelsByProvider !== 'object' ||
-    config.lastModelsByProvider === DEFAULTS.lastModelsByProvider
-  ) {
-    config.lastModelsByProvider = {
-      ...(config.lastModelsByProvider &&
-      typeof config.lastModelsByProvider === 'object' &&
-      config.lastModelsByProvider !== DEFAULTS.lastModelsByProvider
-        ? config.lastModelsByProvider
-        : {}),
-    };
-  }
-  config.lastModelsByProvider[provider] = id;
-}
-
-/**
- * Pick model for a provider: preferred if in catalog, else last stored, else no selection.
- * @param {object} config
- * @param {'claude' | 'openrouter'} provider
- * @param {string} [preferredModel]
+ * @param {string} currentModel
  * @returns {string}
  */
-function resolveModelForProvider(config, provider, preferredModel) {
-  const candidate =
-    preferredModel != null ? preferredModel : config.model;
-  if (!isNoModel(candidate) && isModelIdForProvider(candidate, provider)) {
-    return String(candidate).trim();
-  }
-  const stored = config.lastModelsByProvider?.[provider];
-  if (
-    typeof stored === 'string' &&
-    !isNoModel(stored) &&
-    isModelIdForProvider(stored, provider)
-  ) {
+function migrateLegacyModel(raw, currentModel) {
+  if (isNoModel(currentModel)) return NO_MODEL;
+  if (isClaudeCatalogId(currentModel)) return String(currentModel).trim();
+
+  const stored =
+    raw != null &&
+    typeof raw === 'object' &&
+    !Array.isArray(raw) &&
+    typeof /** @type {Record<string, unknown>} */ (raw).lastModelsByProvider === 'object'
+      ? /** @type {Record<string, unknown>} */ (
+          /** @type {Record<string, unknown>} */ (raw).lastModelsByProvider
+        ).claude
+      : null;
+
+  if (typeof stored === 'string' && isClaudeCatalogId(stored)) {
     return stored.trim();
   }
-  return NO_MODEL;
+  return DEFAULT_MODEL;
 }
 
 /**
@@ -294,9 +239,7 @@ function persistable(config) {
     maxAgentTurns: config.maxAgentTurns,
     allowedTools: config.allowedTools,
     agentTimeoutMs: config.agentTimeoutMs,
-    llmProvider: isValidLlmProvider(config.llmProvider) ? config.llmProvider : 'claude',
     model: config.model,
-    lastModelsByProvider: normalizeLastModelsByProvider(config.lastModelsByProvider),
     ticketSource: config.ticketSource,
     jiraBaseUrl: config.jiraBaseUrl || '',
     jiraPrLinkPhrase: config.jiraPrLinkPhrase || 'Relates to',
@@ -336,11 +279,9 @@ export function loadConfig(repoRoot) {
     const initial = {
       ...DEFAULTS,
       allowedTools: [...KNOWN_TOOLS],
-      lastModelsByProvider: {},
       jiraRules: structuredClone(DEFAULT_JIRA_RULES),
       githubRules: structuredClone(DEFAULT_GITHUB_RULES),
     };
-    rememberModelForProvider(initial, 'claude', initial.model);
     fs.writeFileSync(configPath, JSON.stringify(persistable(initial), null, 2) + '\n', 'utf8');
     return initial;
   }
@@ -350,29 +291,34 @@ export function loadConfig(repoRoot) {
     ...DEFAULTS,
     ...raw,
     allowedTools: raw.allowedTools ?? [...KNOWN_TOOLS],
-    lastModelsByProvider: normalizeLastModelsByProvider(raw.lastModelsByProvider),
     jiraRules: normalizeJiraRules(raw.jiraRules),
     githubRules: normalizeGithubRules(raw.githubRules),
   };
 
+  let needsSave = false;
+
   if (isNoModel(config.model)) {
     if (String(config.model).trim() !== NO_MODEL) {
       config.model = NO_MODEL;
-      saveConfig(repoRoot, persistable(config));
+      needsSave = true;
     } else {
       config.model = NO_MODEL;
     }
   } else if (!isValidModelId(config.model)) {
-    config.model = defaultModelForProvider(
-      isValidLlmProvider(config.llmProvider) ? config.llmProvider : 'claude'
-    );
-    saveConfig(repoRoot, persistable(config));
+    config.model = DEFAULT_MODEL;
+    needsSave = true;
   } else {
-    config.model = String(config.model).trim();
+    const migrated = migrateLegacyModel(raw, config.model);
+    if (migrated !== String(config.model).trim()) {
+      config.model = migrated;
+      needsSave = true;
+    } else {
+      config.model = String(config.model).trim();
+    }
   }
 
-  if (!isValidLlmProvider(config.llmProvider)) {
-    config.llmProvider = 'claude';
+  if (raw.llmProvider === 'openrouter' || raw.lastModelsByProvider != null) {
+    needsSave = true;
   }
 
   if (!ALLOWED_TICKET_SOURCES.has(config.ticketSource)) {
@@ -387,10 +333,9 @@ export function loadConfig(repoRoot) {
     config.jiraPrLinkPhrase = 'Relates to';
   }
 
-  const loadedProvider = isValidLlmProvider(config.llmProvider)
-    ? config.llmProvider
-    : 'claude';
-  rememberModelForProvider(config, loadedProvider, config.model);
+  if (needsSave) {
+    saveConfig(repoRoot, persistable(config));
+  }
 
   return config;
 }
@@ -404,23 +349,6 @@ export function loadConfig(repoRoot) {
  * @returns {typeof DEFAULTS}
  */
 export function updateConfig(repoRoot, config, patch) {
-  if (!config.lastModelsByProvider || typeof config.lastModelsByProvider !== 'object') {
-    config.lastModelsByProvider = normalizeLastModelsByProvider(config.lastModelsByProvider);
-  }
-
-  const prevProvider = isValidLlmProvider(config.llmProvider)
-    ? config.llmProvider
-    : 'claude';
-  let providerChanged = false;
-  const willChangeProvider =
-    patch.llmProvider !== undefined &&
-    isValidLlmProvider(patch.llmProvider) &&
-    patch.llmProvider !== prevProvider;
-
-  if (willChangeProvider) {
-    rememberModelForProvider(config, prevProvider, config.model);
-  }
-
   if (patch.model != null) {
     if (isNoModel(patch.model)) {
       config.model = NO_MODEL;
@@ -428,33 +356,13 @@ export function updateConfig(repoRoot, config, patch) {
       throw new Error(
         `Invalid model "${patch.model}". Expected a non-empty model id or "${NO_MODEL}" for no selection`
       );
-    } else {
-      config.model = String(patch.model).trim();
-    }
-  }
-
-  if (patch.llmProvider !== undefined) {
-    if (!isValidLlmProvider(patch.llmProvider)) {
+    } else if (!isClaudeCatalogId(String(patch.model).trim())) {
       throw new Error(
-        `Invalid llmProvider "${patch.llmProvider}". Allowed: ${LLM_PROVIDERS.join(', ')}`
+        `Invalid model "${patch.model}". Expected a Claude model id (no provider/ prefix)`
       );
+    } else {
+      config.model = String(patch.model).trim();
     }
-    providerChanged = willChangeProvider;
-    config.llmProvider = patch.llmProvider;
-  }
-
-  const currentProvider = isValidLlmProvider(config.llmProvider)
-    ? config.llmProvider
-    : 'claude';
-
-  if (providerChanged) {
-    config.model = resolveModelForProvider(config, currentProvider, config.model);
-  }
-
-  if (patch.model != null && !providerChanged) {
-    rememberModelForProvider(config, currentProvider, config.model);
-  } else if (providerChanged && !isNoModel(config.model)) {
-    rememberModelForProvider(config, currentProvider, config.model);
   }
 
   if (patch.baseBranch !== undefined) {
@@ -545,18 +453,14 @@ export function updateConfig(repoRoot, config, patch) {
  *   stubAgent?: boolean,
  *   ghAuth?: import('./gh-auth.js').GhAuthResult,
  *   claudeAuth?: import('./claude-auth.js').ClaudeAuthResult,
- *   openrouterAuth?: import('./openrouter-auth.js').OpenRouterAuthResult,
  * }} [opts]
  */
 export function publicConfig(config, opts = {}) {
-  const llmProvider = isValidLlmProvider(config.llmProvider)
-    ? config.llmProvider
-    : 'claude';
   const model = isNoModel(config.model)
     ? NO_MODEL
-    : isValidModelId(config.model)
+    : isValidModelId(config.model) && isClaudeCatalogId(config.model)
       ? String(config.model).trim()
-      : defaultModelForProvider(llmProvider);
+      : DEFAULT_MODEL;
   const repoName = opts.repoRoot ? path.basename(opts.repoRoot) : undefined;
   const ticketSource = ALLOWED_TICKET_SOURCES.has(config.ticketSource)
     ? config.ticketSource
@@ -581,19 +485,15 @@ export function publicConfig(config, opts = {}) {
 
   const ghAuth = opts.ghAuth ?? checkGhAuth();
   const claudeAuth = opts.claudeAuth ?? checkClaudeAuth();
-  const openrouterAuth = opts.openrouterAuth ?? checkOpenRouterAuth();
   const origin = originRemoteInfo(opts.repoRoot);
   const ghTokenMask = maskSecret(githubTokenFromEnv());
   const anthropicMask = maskSecret(process.env.ANTHROPIC_API_KEY);
   const claudeOauthMask = maskSecret(process.env.CLAUDE_CODE_OAUTH_TOKEN);
-  const openrouterMask = maskSecret(process.env.OPENROUTER_API_KEY);
 
-  const curatedModels = curatedModelOptions(llmProvider);
+  const curatedModels = curatedModelOptions();
 
   return {
-    llmProvider,
     model,
-    lastModelsByProvider: normalizeLastModelsByProvider(config.lastModelsByProvider),
     baseBranch: config.baseBranch,
     testCommand: config.testCommand ?? null,
     maxAgentTurns: config.maxAgentTurns,
@@ -625,13 +525,7 @@ export function publicConfig(config, opts = {}) {
     anthropicApiKeyMasked: anthropicMask.masked,
     claudeOauthTokenSet: claudeOauthMask.set,
     claudeOauthTokenMasked: claudeOauthMask.masked,
-    openrouterAuthOk: openrouterAuth.ok === true,
-    openrouterApiKeySet: openrouterMask.set,
-    openrouterApiKeyMasked: openrouterMask.masked,
-    llmAuthOk:
-      llmProvider === 'openrouter'
-        ? openrouterAuth.ok === true
-        : claudeAuth.ok === true,
+    llmAuthOk: claudeAuth.ok === true,
     stubAgent: opts.stubAgent === true,
     ...(repoName ? { repoName } : {}),
   };

package/src/git.js

@@ -103,6 +103,68 @@ export function buildBranchName(type, title) {
   return `${type}/${slugifyTitle(title)}`;
 }
 
+const PREFERRED_BRANCH_MAX = 100;
+
+/**
+ * Sanitize a user-supplied git branch name. Preserves case (e.g. NC-2133).
+ * Empty / whitespace-only input returns ''.
+ * @param {unknown} raw
+ */
+export function normalizePreferredBranchName(raw) {
+  if (raw == null) return '';
+  let name = String(raw).trim().replace(/\s+/g, '-');
+  if (!name) return '';
+
+  name = name
+    .replace(/[~^:?*\[\\]+/g, '-')
+    .replace(/@{/g, '-at-')
+    .replace(/[^A-Za-z0-9._/-]+/g, '-')
+    .replace(/\/+/g, '/')
+    .replace(/\.{2,}/g, '.')
+    .replace(/-{2,}/g, '-')
+    .replace(/^[-./]+|[-./]+$/g, '');
+
+  if (/\.lock$/i.test(name)) {
+    name = name.replace(/\.lock$/i, '').replace(/[-./]+$/g, '');
+  }
+
+  name = name.slice(0, PREFERRED_BRANCH_MAX).replace(/[-./]+$/g, '');
+  if (!name || name === '@' || /^HEAD$/i.test(name)) return '';
+  return name;
+}
+
+/**
+ * Parse optional branchName from an API body.
+ * Omitted / blank → no preference (caller uses feat/fix slug).
+ * Provided but invalid after sanitize → error.
+ * @param {unknown} raw
+ * @returns {{ ok: true, value?: string } | { ok: false, error: string }}
+ */
+export function parsePreferredBranchName(raw) {
+  if (raw == null) return { ok: true };
+  if (typeof raw !== 'string') {
+    return { ok: false, error: 'branchName must be a string' };
+  }
+  if (!raw.trim()) return { ok: true };
+  const value = normalizePreferredBranchName(raw);
+  if (!value) {
+    return { ok: false, error: 'branchName is not a valid git branch name' };
+  }
+  return { ok: true, value };
+}
+
+/**
+ * Prefer a user-supplied branch name; otherwise feat/fix slug from the ticket.
+ * @param {string | undefined | null} preferred
+ * @param {'feat' | 'fix'} issueType
+ * @param {string} issueTitle
+ */
+export function resolveDesiredBranchName(preferred, issueType, issueTitle) {
+  const custom = normalizePreferredBranchName(preferred);
+  if (custom) return custom;
+  return buildBranchName(issueType, issueTitle);
+}
+
 /**
  * @param {string} repoRoot
  * @param {string | number} worktreeId GitHub issue number or Jira key