@icode-js/icode 3.0.2

package/src/core/ai-commit-summary.js

@@ -0,0 +1,18 @@
+/**
+ * Format an AI commit result so the commit id is kept on the first line and
+ * multiline body content is preserved for later lines.
+ */
+export function formatAiCommitSummary(commitId, commitMessage) {
+  const normalizedMessage = String(commitMessage || '').trim()
+
+  if (!normalizedMessage) {
+    return commitId ? String(commitId).trim() : '无标题'
+  }
+
+  if (!commitId) {
+    return normalizedMessage
+  }
+
+  const [header, ...restLines] = normalizedMessage.split('\n')
+  return [`${String(commitId).trim()} ${header}`, ...restLines].join('\n').trim()
+}

package/src/core/ai-config.js

@@ -0,0 +1,342 @@
+import { IcodeError } from './errors.js'
+import { readConfig, writeConfig } from './config-store.js'
+
+const DEFAULT_PROFILE = {
+  provider: 'custom',
+  format: 'openai',
+  baseUrl: '',
+  apiKey: '',
+  model: '',
+  temperature: 0.2,
+  maxTokens: 1200,
+  headers: {},
+  requestBody: {}
+}
+
+const ALLOWED_OPTION_SCOPES = new Set(['commit', 'conflict', 'explain', 'push'])
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value))
+}
+
+function normalizeFormat(format) {
+  const normalized = (format || 'openai').trim().toLowerCase()
+  if (!['openai', 'anthropic', 'ollama'].includes(normalized)) {
+    throw new IcodeError(`不支持的 AI 接口格式: ${format}`, {
+      code: 'AI_FORMAT_INVALID',
+      exitCode: 2
+    })
+  }
+  return normalized
+}
+
+function ensureAiSection(config) {
+  if (!config.ai || typeof config.ai !== 'object') {
+    config.ai = {
+      activeProfile: '',
+      profiles: {}
+    }
+  }
+
+  if (!config.ai.profiles || typeof config.ai.profiles !== 'object') {
+    config.ai.profiles = {}
+  }
+
+  if (!config.ai.options || typeof config.ai.options !== 'object' || Array.isArray(config.ai.options)) {
+    config.ai.options = {}
+  }
+
+  if (typeof config.ai.activeProfile !== 'string') {
+    config.ai.activeProfile = ''
+  }
+
+  return config
+}
+
+function normalizeProfile(profile = {}) {
+  const next = {
+    ...clone(DEFAULT_PROFILE),
+    ...profile,
+    provider: (profile.provider || DEFAULT_PROFILE.provider).trim(),
+    format: normalizeFormat(profile.format || DEFAULT_PROFILE.format),
+    baseUrl: (profile.baseUrl || '').trim(),
+    apiKey: (profile.apiKey || '').trim(),
+    model: (profile.model || '').trim(),
+    temperature: Number.isFinite(Number(profile.temperature)) ? Number(profile.temperature) : DEFAULT_PROFILE.temperature,
+    maxTokens: Number.isFinite(Number(profile.maxTokens)) ? Number(profile.maxTokens) : DEFAULT_PROFILE.maxTokens,
+    headers: profile.headers && typeof profile.headers === 'object' ? profile.headers : {},
+    requestBody: profile.requestBody && typeof profile.requestBody === 'object' && !Array.isArray(profile.requestBody) ? profile.requestBody : {}
+  }
+
+  return next
+}
+
+function resolveActiveProfileName(aiConfig) {
+  const active = (aiConfig.activeProfile || '').trim()
+  if (active && aiConfig.profiles[active]) {
+    return active
+  }
+
+  const names = Object.keys(aiConfig.profiles)
+  return names[0] || ''
+}
+
+function maskKey(value) {
+  const raw = (value || '').trim()
+  if (!raw) {
+    return ''
+  }
+
+  if (raw.length <= 8) {
+    return `${raw.slice(0, 2)}****${raw.slice(-1)}`
+  }
+
+  return `${raw.slice(0, 4)}****${raw.slice(-4)}`
+}
+
+export function getAiConfig() {
+  const config = ensureAiSection(readConfig())
+  const activeProfile = resolveActiveProfileName(config.ai)
+  const sanitizedOptions = sanitizeAiCommandOptions(config.ai.options)
+  const activeProfileChanged = activeProfile && config.ai.activeProfile !== activeProfile
+  const optionsChanged = JSON.stringify(config.ai.options || {}) !== JSON.stringify(sanitizedOptions)
+
+  if (activeProfileChanged) {
+    config.ai.activeProfile = activeProfile
+  }
+
+  if (optionsChanged) {
+    config.ai.options = sanitizedOptions
+  }
+
+  if (activeProfileChanged || optionsChanged) {
+    writeConfig(config)
+  }
+
+  return config.ai
+}
+
+function sanitizeAiCommandOptions(optionsMap) {
+  const source = optionsMap && typeof optionsMap === 'object' && !Array.isArray(optionsMap) ? optionsMap : {}
+  const next = {}
+
+  Object.entries(source).forEach(([scope, value]) => {
+    if (!ALLOWED_OPTION_SCOPES.has(scope)) {
+      return
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return
+    }
+    next[scope] = clone(value)
+  })
+
+  return next
+}
+
+function normalizeOptionScope(scopeName) {
+  const scope = (scopeName || '').trim().toLowerCase()
+  if (!scope) {
+    throw new IcodeError('缺少 options 作用域。可选: commit|conflict|explain|push', {
+      code: 'AI_OPTIONS_SCOPE_EMPTY',
+      exitCode: 2
+    })
+  }
+
+  if (!ALLOWED_OPTION_SCOPES.has(scope)) {
+    throw new IcodeError(`不支持的 options 作用域: ${scopeName}`, {
+      code: 'AI_OPTIONS_SCOPE_INVALID',
+      exitCode: 2
+    })
+  }
+
+  return scope
+}
+
+function normalizeOptionsPayload(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new IcodeError('options 内容必须是 JSON 对象', {
+      code: 'AI_OPTIONS_PAYLOAD_INVALID',
+      exitCode: 2
+    })
+  }
+
+  return payload
+}
+
+export function listAiProfiles() {
+  const aiConfig = getAiConfig()
+
+  return Object.entries(aiConfig.profiles).map(([name, profile]) => {
+    const normalized = normalizeProfile(profile)
+    const { apiKey, ...rest } = normalized
+    return {
+      name,
+      ...rest,
+      hasApiKey: Boolean(apiKey),
+      apiKeyMasked: maskKey(apiKey),
+      isActive: aiConfig.activeProfile === name
+    }
+  })
+}
+
+export function listAiCommandOptions() {
+  const aiConfig = getAiConfig()
+  return sanitizeAiCommandOptions(aiConfig.options)
+}
+
+export function getAiCommandOptions(scopeName = '') {
+  const aiConfig = getAiConfig()
+  if (!scopeName) {
+    return sanitizeAiCommandOptions(aiConfig.options)
+  }
+
+  const scope = normalizeOptionScope(scopeName)
+  const scoped = aiConfig.options?.[scope]
+  if (!scoped || typeof scoped !== 'object' || Array.isArray(scoped)) {
+    return {}
+  }
+
+  return clone(scoped)
+}
+
+export function upsertAiCommandOptions(scopeName, payload, options = {}) {
+  const scope = normalizeOptionScope(scopeName)
+  const normalizedPayload = normalizeOptionsPayload(payload)
+  const replace = options.replace === true
+
+  const config = ensureAiSection(readConfig())
+  const current = config.ai.options?.[scope]
+  const currentObject = current && typeof current === 'object' && !Array.isArray(current) ? current : {}
+
+  config.ai.options[scope] = replace
+    ? clone(normalizedPayload)
+    : {
+        ...currentObject,
+        ...clone(normalizedPayload)
+      }
+
+  writeConfig(config)
+  return clone(config.ai.options[scope])
+}
+
+export function removeAiCommandOptions(scopeName) {
+  const scope = normalizeOptionScope(scopeName)
+  const config = ensureAiSection(readConfig())
+  delete config.ai.options[scope]
+  writeConfig(config)
+}
+
+export function getAiProfile(profileName = '') {
+  const aiConfig = getAiConfig()
+  const name = (profileName || aiConfig.activeProfile || '').trim()
+
+  if (!name) {
+    throw new IcodeError('未配置 AI profile。请先执行: icode config ai set <name> ...', {
+      code: 'AI_PROFILE_EMPTY',
+      exitCode: 2
+    })
+  }
+
+  const rawProfile = aiConfig.profiles[name]
+  if (!rawProfile) {
+    throw new IcodeError(`AI profile 不存在: ${name}`, {
+      code: 'AI_PROFILE_MISSING',
+      exitCode: 2
+    })
+  }
+
+  return {
+    name,
+    ...normalizeProfile(rawProfile)
+  }
+}
+
+export function upsertAiProfile(profileName, partialProfile) {
+  const name = (profileName || '').trim()
+  if (!name) {
+    throw new IcodeError('profile 名称不能为空', {
+      code: 'AI_PROFILE_NAME_EMPTY',
+      exitCode: 2
+    })
+  }
+
+  const config = ensureAiSection(readConfig())
+  const current = config.ai.profiles[name] || {}
+  const nextProfile = normalizeProfile({
+    ...current,
+    ...partialProfile
+  })
+
+  config.ai.profiles[name] = nextProfile
+  if (!config.ai.activeProfile) {
+    config.ai.activeProfile = name
+  }
+
+  writeConfig(config)
+  return {
+    name,
+    ...nextProfile
+  }
+}
+
+export function removeAiProfile(profileName) {
+  const name = (profileName || '').trim()
+  if (!name) {
+    throw new IcodeError('profile 名称不能为空', {
+      code: 'AI_PROFILE_NAME_EMPTY',
+      exitCode: 2
+    })
+  }
+
+  const config = ensureAiSection(readConfig())
+  if (!config.ai.profiles[name]) {
+    throw new IcodeError(`AI profile 不存在: ${name}`, {
+      code: 'AI_PROFILE_MISSING',
+      exitCode: 2
+    })
+  }
+
+  delete config.ai.profiles[name]
+
+  if (config.ai.activeProfile === name) {
+    config.ai.activeProfile = Object.keys(config.ai.profiles)[0] || ''
+  }
+
+  writeConfig(config)
+}
+
+export function useAiProfile(profileName) {
+  const name = (profileName || '').trim()
+  if (!name) {
+    throw new IcodeError('profile 名称不能为空', {
+      code: 'AI_PROFILE_NAME_EMPTY',
+      exitCode: 2
+    })
+  }
+
+  const config = ensureAiSection(readConfig())
+  if (!config.ai.profiles[name]) {
+    throw new IcodeError(`AI profile 不存在: ${name}`, {
+      code: 'AI_PROFILE_MISSING',
+      exitCode: 2
+    })
+  }
+
+  config.ai.activeProfile = name
+  writeConfig(config)
+  return getAiProfile(name)
+}
+
+export function getAiProfileForDisplay(profileName = '') {
+  const profile = getAiProfile(profileName)
+  const { apiKey, ...rest } = profile
+  return {
+    ...rest,
+    hasApiKey: Boolean(apiKey),
+    apiKeyMasked: maskKey(apiKey)
+  }
+}
+
+export function maskApiKey(value) {
+  return maskKey(value)
+}

package/src/core/ai-diff-range.js

@@ -0,0 +1,117 @@
+import { IcodeError } from './errors.js'
+import { logger } from './logger.js'
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))]
+}
+
+function readCommandErrorOutput(error) {
+  return `${error?.meta?.stderr || ''}\n${error?.meta?.stdout || ''}\n${error?.message || ''}`.trim()
+}
+
+function summarizeGitError(error) {
+  const text = readCommandErrorOutput(error)
+  if (!text) {
+    return ''
+  }
+
+  const lines = text
+    .split('\n')
+    .map((item) => item.trim())
+    .filter(Boolean)
+
+  return lines[0] || ''
+}
+
+export async function resolveAiDiffRange({ git, context, baseRef = '', headRef = 'HEAD', label = 'AI', explicitHead = false }) {
+  const explicitBase = Boolean((baseRef || '').trim())
+  const remoteDefaultBase = `origin/${context.defaultBranch}`
+  const localDefaultBase = context.defaultBranch || ''
+  const candidates = explicitBase
+    ? [(baseRef || '').trim()]
+    : unique([remoteDefaultBase, localDefaultBase])
+
+  if (explicitHead) {
+    const headResult = await git.exec(['rev-parse', '--verify', `${headRef}^{commit}`], {
+      allowFailure: true
+    })
+
+    if (headResult.exitCode !== 0) {
+      const reason = summarizeGitError({
+        meta: {
+          stderr: headResult.stderr || '',
+          stdout: headResult.stdout || ''
+        }
+      })
+
+      throw new IcodeError(`指定终点不可用: ${headRef}${reason ? ` (${reason})` : ''}`, {
+        code: 'AI_DIFF_HEAD_INVALID',
+        exitCode: 2,
+        meta: {
+          headRef,
+          reason,
+          stderr: headResult.stderr || '',
+          stdout: headResult.stdout || ''
+        }
+      })
+    }
+  }
+
+  let lastError = null
+
+  for (let index = 0; index < candidates.length; index += 1) {
+    const candidateBase = candidates[index]
+    try {
+      const rangeResult = await git.diffBetween(candidateBase, headRef, { style: 'three-dot' })
+
+      if (!explicitBase && index > 0) {
+        logger.warn(`${label} 默认基线 ${remoteDefaultBase} 不可用，已回退到本地分支 ${candidateBase}。`)
+      }
+
+      return {
+        ...rangeResult,
+        baseRef: candidateBase,
+        explicitBase
+      }
+    } catch (error) {
+      lastError = error
+      if (explicitBase) {
+        break
+      }
+    }
+  }
+
+  const reason = summarizeGitError(lastError)
+
+  if (explicitBase) {
+    throw new IcodeError(`指定基线不可用: ${baseRef}${reason ? ` (${reason})` : ''}`, {
+      code: 'AI_DIFF_BASE_INVALID',
+      exitCode: 2,
+      cause: lastError,
+      meta: {
+        baseRef,
+        headRef,
+        reason,
+        stderr: lastError?.meta?.stderr || '',
+        stdout: lastError?.meta?.stdout || ''
+      }
+    })
+  }
+
+  throw new IcodeError(
+    `默认基线 ${remoteDefaultBase} 不可用，且无法回退到本地分支 ${localDefaultBase || '(empty)'}${reason ? ` (${reason})` : ''}`,
+    {
+      code: 'AI_DIFF_BASE_UNAVAILABLE',
+      exitCode: 2,
+      cause: lastError,
+      meta: {
+        baseRef: remoteDefaultBase,
+        fallbackBase: localDefaultBase,
+        headRef,
+        reason,
+        stderr: lastError?.meta?.stderr || '',
+        stdout: lastError?.meta?.stdout || ''
+      }
+    }
+  )
+}

package/src/core/args.js

@@ -0,0 +1,47 @@
+const LEGACY_ALIAS_MAP = new Map([
+  ['-pm', '--pull-main'],
+  ['--pullMainBranch', '--pull-main'],
+  ['--pushOrigin', '--push-origin'],
+  ['--notPushCurrent', '--not-push-current'],
+  ['--repoMode', '--repo-mode'],
+  ['--noVerify', '--no-verify'],
+  ['--allLocal', '--all-local'],
+  ['--mergeMain', '--merge-main'],
+  ['--aiReview', '--ai-review'],
+  ['--aiProfile', '--ai-profile'],
+  ['--aiCommit', '--ai-commit']
+])
+
+export function normalizeLegacyArgs(argv = []) {
+  return argv.map((arg) => LEGACY_ALIAS_MAP.get(arg) || arg)
+}
+
+export function parseConfigValue(raw) {
+  if (raw === 'true') {
+    return true
+  }
+  if (raw === 'false') {
+    return false
+  }
+  if (raw === 'null') {
+    return null
+  }
+  if (raw === 'undefined') {
+    return undefined
+  }
+
+  const numberValue = Number(raw)
+  if (Number.isFinite(numberValue) && raw.trim() !== '') {
+    return numberValue
+  }
+
+  if ((raw.startsWith('{') && raw.endsWith('}')) || (raw.startsWith('[') && raw.endsWith(']'))) {
+    try {
+      return JSON.parse(raw)
+    } catch {
+      return raw
+    }
+  }
+
+  return raw
+}

package/src/core/commit-conventions.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const RELEVANT_HOOK_NAMES = ['commit-msg', 'prepare-commit-msg', 'pre-commit']
+const RELEVANT_CONFIG_FILES = [
+  'commitlint.config.js',
+  'commitlint.config.cjs',
+  'commitlint.config.mjs',
+  'commitlint.config.ts',
+  '.commitlintrc',
+  '.commitlintrc.json',
+  '.commitlintrc.js',
+  '.commitlintrc.cjs',
+  '.commitlintrc.mjs',
+  '.commitlintrc.yaml',
+  '.commitlintrc.yml'
+]
+const MAX_FILE_SNIPPET = 1200
+const MAX_PACKAGE_SNIPPET = 1600
+const MAX_SUMMARY_LENGTH = 4000
+
+function unique(values) {
+  return [...new Set(values)]
+}
+
+function fileExists(filePath) {
+  try {
+    return fs.statSync(filePath).isFile()
+  } catch {
+    return false
+  }
+}
+
+function readTextSnippet(filePath, limit) {
+  const text = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n').trim()
+  if (!text) {
+    return ''
+  }
+
+  if (text.length <= limit) {
+    return text
+  }
+
+  return `${text.slice(0, limit)}\n...<truncated>`
+}
+
+function collectHookFiles(context) {
+  const candidateDirs = []
+
+  if (context.hasHuskyFolder) {
+    candidateDirs.push(path.resolve(context.topLevelPath, '.husky'))
+  }
+
+  if (context.hasHookPath) {
+    candidateDirs.push(context.hookPath)
+  }
+
+  return unique(candidateDirs)
+    .flatMap((dirPath) => RELEVANT_HOOK_NAMES.map((fileName) => path.resolve(dirPath, fileName)))
+    .filter(fileExists)
+}
+
+function collectConfigFiles(topLevelPath) {
+  return RELEVANT_CONFIG_FILES
+    .map((fileName) => path.resolve(topLevelPath, fileName))
+    .filter(fileExists)
+}
+
+function extractPackageJsonSnippet(topLevelPath) {
+  const packageJsonPath = path.resolve(topLevelPath, 'package.json')
+  if (!fileExists(packageJsonPath)) {
+    return ''
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    const relevant = {}
+    const scripts = Object.entries(pkg.scripts || {})
+      .filter(([name]) => /commit|lint|husky/i.test(name))
+      .slice(0, 8)
+
+    if (scripts.length) {
+      relevant.scripts = Object.fromEntries(scripts)
+    }
+
+    if (pkg.commitlint && typeof pkg.commitlint === 'object') {
+      relevant.commitlint = pkg.commitlint
+    }
+
+    if (pkg.husky && typeof pkg.husky === 'object') {
+      relevant.husky = pkg.husky
+    }
+
+    if (pkg['lint-staged'] && typeof pkg['lint-staged'] === 'object') {
+      relevant['lint-staged'] = pkg['lint-staged']
+    }
+
+    if (pkg.config?.commitizen && typeof pkg.config.commitizen === 'object') {
+      relevant.commitizen = pkg.config.commitizen
+    }
+
+    if (!Object.keys(relevant).length) {
+      return ''
+    }
+
+    const text = JSON.stringify(relevant, null, 2)
+    if (text.length <= MAX_PACKAGE_SNIPPET) {
+      return text
+    }
+
+    return `${text.slice(0, MAX_PACKAGE_SNIPPET)}\n...<truncated>`
+  } catch {
+    return ''
+  }
+}
+
+function buildFileSection(topLevelPath, filePath, limit = MAX_FILE_SNIPPET) {
+  const snippet = readTextSnippet(filePath, limit)
+  if (!snippet) {
+    return ''
+  }
+
+  return `[${path.relative(topLevelPath, filePath) || path.basename(filePath)}]\n${snippet}`
+}
+
+function truncateSummary(text) {
+  if (text.length <= MAX_SUMMARY_LENGTH) {
+    return text
+  }
+
+  return `${text.slice(0, MAX_SUMMARY_LENGTH)}\n\n...<truncated>`
+}
+
+export function scanCommitConventions(context) {
+  const hookFiles = collectHookFiles(context)
+  const hookSections = hookFiles
+    .map((filePath) => buildFileSection(context.topLevelPath, filePath))
+    .filter(Boolean)
+
+  const configFiles = collectConfigFiles(context.topLevelPath)
+  const configSections = configFiles
+    .map((filePath) => buildFileSection(context.topLevelPath, filePath))
+    .filter(Boolean)
+
+  const packageJsonSnippet = extractPackageJsonSnippet(context.topLevelPath)
+  const sections = []
+
+  if (hookSections.length) {
+    sections.push(`Relevant Git hooks:\n${hookSections.join('\n\n')}`)
+  }
+
+  if (configSections.length) {
+    sections.push(`Relevant commit config files:\n${configSections.join('\n\n')}`)
+  }
+
+  if (packageJsonSnippet) {
+    sections.push(`Relevant package.json fields:\n[package.json]\n${packageJsonSnippet}`)
+  }
+
+  return {
+    hasConventions: sections.length > 0,
+    summary: truncateSummary(sections.join('\n\n')),
+    sources: [
+      ...hookFiles.map((filePath) => path.relative(context.topLevelPath, filePath) || path.basename(filePath)),
+      ...configFiles.map((filePath) => path.relative(context.topLevelPath, filePath) || path.basename(filePath)),
+      ...(packageJsonSnippet ? ['package.json'] : [])
+    ]
+  }
+}