@colin4k1024/tsp 2.4.7 → 2.4.9

package/scripts/hooks/codegraph-auto-init.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { resolveCodeGraphBin } = require('../install-codegraph');
+
+const STATE_FILE = path.join('.codegraph', 'tsp-auto-init-state.json');
+const DEFAULT_RETRY_MS = 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
+const PROJECT_MARKERS = Object.freeze([
+  'package.json',
+  'pyproject.toml',
+  'Cargo.toml',
+  'go.mod',
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts',
+  'Gemfile',
+  'composer.json',
+  'mix.exs',
+  'deno.json',
+  'deno.jsonc',
+  'README.md',
+  'AGENTS.md',
+  'CLAUDE.md',
+]);
+
+function isDisabled() {
+  const value = String(process.env.TSP_CODEGRAPH_AUTO_INIT || '').trim().toLowerCase();
+  return value === '0' || value === 'false' || value === 'off';
+}
+
+function readHookInput(rawInput) {
+  if (!rawInput || !String(rawInput).trim()) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(rawInput);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizePath(candidate) {
+  try {
+    return fs.realpathSync(candidate);
+  } catch {
+    return path.resolve(candidate);
+  }
+}
+
+function getStartDir(rawInput) {
+  if (process.env.CODEGRAPH_AUTO_INIT_PROJECT_ROOT) {
+    return path.resolve(process.env.CODEGRAPH_AUTO_INIT_PROJECT_ROOT);
+  }
+
+  const input = readHookInput(rawInput);
+  const candidates = [
+    input.cwd,
+    input.projectDir,
+    input.project_dir,
+    input.projectPath,
+    input.project_path,
+    input.workspaceDir,
+    input.workspace_dir,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return path.resolve(candidate.trim());
+    }
+  }
+
+  return process.cwd();
+}
+
+function parseGitDirFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8').trim();
+    const match = content.match(/^gitdir:\s*(.+)$/i);
+    if (!match) {
+      return null;
+    }
+    const gitDir = match[1].trim();
+    return path.resolve(path.dirname(filePath), gitDir);
+  } catch {
+    return null;
+  }
+}
+
+function findGitRoot(startDir) {
+  let current = normalizePath(startDir);
+  const root = path.parse(current).root;
+
+  while (current && current !== root) {
+    const gitPath = path.join(current, '.git');
+    if (fs.existsSync(gitPath)) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+
+  const rootGitPath = path.join(root, '.git');
+  return fs.existsSync(rootGitPath) ? root : null;
+}
+
+function findMarkerRoot(startDir) {
+  let current = normalizePath(startDir);
+  const root = path.parse(current).root;
+  const home = normalizePath(os.homedir());
+
+  while (current && current !== root) {
+    if (current === home) {
+      return null;
+    }
+    if (PROJECT_MARKERS.some(marker => fs.existsSync(path.join(current, marker)))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+
+  return null;
+}
+
+function resolveProjectRoot(rawInput) {
+  const startDir = getStartDir(rawInput);
+  if (!fs.existsSync(startDir)) {
+    return null;
+  }
+
+  return findGitRoot(startDir) || findMarkerRoot(startDir);
+}
+
+function codegraphDbPath(projectRoot) {
+  return path.join(projectRoot, '.codegraph', 'codegraph.db');
+}
+
+function statePath(projectRoot) {
+  return path.join(projectRoot, STATE_FILE);
+}
+
+function readState(projectRoot) {
+  try {
+    return JSON.parse(fs.readFileSync(statePath(projectRoot), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeState(projectRoot, state) {
+  const filePath = statePath(projectRoot);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function retryDelayMs() {
+  const parsed = Number(process.env.TSP_CODEGRAPH_AUTO_INIT_RETRY_MS || DEFAULT_RETRY_MS);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_RETRY_MS;
+}
+
+function shouldThrottleFailure(projectRoot, now = Date.now()) {
+  const state = readState(projectRoot);
+  if (state.status !== 'failed' || !state.failedAt) {
+    return false;
+  }
+
+  const failedAt = Date.parse(state.failedAt);
+  if (!Number.isFinite(failedAt)) {
+    return false;
+  }
+
+  return now - failedAt < retryDelayMs();
+}
+
+function resolveGitDir(projectRoot) {
+  const gitPath = path.join(projectRoot, '.git');
+  try {
+    const stat = fs.statSync(gitPath);
+    if (stat.isDirectory()) {
+      return gitPath;
+    }
+    if (stat.isFile()) {
+      return parseGitDirFile(gitPath);
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function ensureGitExclude(projectRoot) {
+  const gitDir = resolveGitDir(projectRoot);
+  if (!gitDir) {
+    return false;
+  }
+
+  const excludePath = path.join(gitDir, 'info', 'exclude');
+  fs.mkdirSync(path.dirname(excludePath), { recursive: true });
+  const existing = fs.existsSync(excludePath) ? fs.readFileSync(excludePath, 'utf8') : '';
+  const lines = existing.split(/\r?\n/).map(line => line.trim());
+  if (lines.includes('.codegraph/')) {
+    return false;
+  }
+
+  const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+  fs.appendFileSync(excludePath, `${prefix}.codegraph/\n`, 'utf8');
+  return true;
+}
+
+function timeoutMs() {
+  const parsed = Number(process.env.TSP_CODEGRAPH_AUTO_INIT_TIMEOUT_MS || DEFAULT_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
+}
+
+function truncate(text, maxLength = 2000) {
+  const value = String(text || '');
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+
+function initializeProject(projectRoot) {
+  const resolved = resolveCodeGraphBin({ ignoreForceStandalone: true });
+  if (!resolved) {
+    throw new Error('CodeGraph binary not found. Install it with the official standalone installer or set CODEGRAPH_INSTALL_BIN.');
+  }
+
+  const result = spawnSync(resolved.command, [...resolved.argsPrefix, 'init', '-i', projectRoot], {
+    cwd: projectRoot,
+    env: process.env,
+    encoding: 'utf8',
+    timeout: timeoutMs(),
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(truncate(`${result.stdout || ''}${result.stderr || ''}`.trim() || `codegraph exited with status ${result.status}`));
+  }
+
+  return {
+    binary: resolved.displayCommand,
+  };
+}
+
+function runAutoInit(rawInput = '') {
+  if (isDisabled()) {
+    return { status: 'skipped', reason: 'disabled' };
+  }
+
+  const projectRoot = resolveProjectRoot(rawInput);
+  if (!projectRoot) {
+    return { status: 'skipped', reason: 'no-project-root' };
+  }
+
+  if (fs.existsSync(codegraphDbPath(projectRoot))) {
+    return { status: 'skipped', reason: 'already-initialized', projectRoot };
+  }
+
+  if (shouldThrottleFailure(projectRoot)) {
+    return { status: 'skipped', reason: 'recent-failure', projectRoot };
+  }
+
+  try {
+    ensureGitExclude(projectRoot);
+    const initialized = initializeProject(projectRoot);
+    writeState(projectRoot, {
+      status: 'initialized',
+      projectRoot,
+      initializedAt: new Date().toISOString(),
+      binary: initialized.binary,
+    });
+    return { status: 'initialized', projectRoot };
+  } catch (error) {
+    writeState(projectRoot, {
+      status: 'failed',
+      projectRoot,
+      failedAt: new Date().toISOString(),
+      error: truncate(error && error.message ? error.message : error),
+    });
+    return { status: 'failed', projectRoot, error };
+  }
+}
+
+function run(rawInput = '') {
+  const result = runAutoInit(rawInput);
+  if (result.status === 'failed' && process.env.TSP_CODEGRAPH_AUTO_INIT_VERBOSE === '1') {
+    return {
+      stderr: `[CodeGraph] auto-init failed for ${result.projectRoot}: ${result.error && result.error.message ? result.error.message : result.error}\n`,
+      exitCode: 0,
+    };
+  }
+  return { exitCode: 0 };
+}
+
+if (require.main === module) {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    raw += chunk;
+  });
+  process.stdin.on('end', () => {
+    run(raw);
+  });
+}
+
+module.exports = {
+  codegraphDbPath,
+  ensureGitExclude,
+  findGitRoot,
+  findMarkerRoot,
+  readState,
+  resolveProjectRoot,
+  run,
+  runAutoInit,
+  shouldThrottleFailure,
+  statePath,
+};

package/scripts/install-apply.js

@@ -218,7 +218,8 @@ function printHumanPlan(plan, dryRun, knownRisks = []) {
   if (Array.isArray(plan.externalInstalls) && plan.externalInstalls.length > 0) {
     console.log('\nPlanned external installs:');
     for (const externalInstall of plan.externalInstalls) {
-      console.log(`- ${externalInstall.id}: ${externalInstall.description || externalInstall.script}`);
+      const mode = externalInstall.failureMode === 'warn' ? ' [warn-on-failure]' : '';
+      console.log(`- ${externalInstall.id}${mode}: ${externalInstall.description || externalInstall.script}`);
     }
   }
 

package/scripts/install-codegraph.js

@@ -1,9 +1,14 @@
 #!/usr/bin/env node
 'use strict'
 
+const fs = require('fs')
+const os = require('os')
 const path = require('path')
 const { spawnSync } = require('child_process')
 
+const INSTALL_SH_URL = 'https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh'
+const INSTALL_PS1_URL = 'https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1'
+
 const SUPPORTED_TARGETS = Object.freeze({
   claude: 'claude',
   codex: 'codex',
@@ -50,29 +55,144 @@ function parseArgs(argv) {
   return parsed
 }
 
-function resolveCodeGraphBin() {
+function isWindows(platform = process.platform) {
+  return platform === 'win32'
+}
+
+function executableNames(name, platform = process.platform) {
+  if (!isWindows(platform)) {
+    return [name]
+  }
+
+  const extensions = String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+    .split(';')
+    .map(value => value.trim().toLowerCase())
+    .filter(Boolean)
+  const lowerName = name.toLowerCase()
+  if (extensions.some(ext => lowerName.endsWith(ext))) {
+    return [name]
+  }
+  return [name, ...extensions.map(ext => `${name}${ext}`)]
+}
+
+function canExecute(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function findOnPath(commandName, options = {}) {
+  const searchPath = options.pathValue !== undefined ? options.pathValue : process.env.PATH
+  const platform = options.platform || process.platform
+  const delimiter = isWindows(platform) ? ';' : path.delimiter
+  const names = executableNames(commandName, platform)
+
+  for (const entry of String(searchPath || '').split(delimiter)) {
+    if (!entry) {
+      continue
+    }
+    for (const name of names) {
+      const candidate = path.join(entry, name)
+      if (canExecute(candidate)) {
+        return candidate
+      }
+    }
+  }
+
+  return null
+}
+
+function defaultCodeGraphCandidates(options = {}) {
+  const homeDir = options.homeDir || os.homedir()
+  const platform = options.platform || process.platform
+
+  if (isWindows(platform)) {
+    const localAppData = process.env.LOCALAPPDATA || path.join(homeDir, 'AppData', 'Local')
+    return [
+      path.join(localAppData, 'codegraph', 'current', 'bin', 'codegraph.exe'),
+      path.join(localAppData, 'codegraph', 'current', 'bin', 'codegraph.cmd'),
+    ]
+  }
+
+  return [
+    path.join(homeDir, '.local', 'bin', 'codegraph'),
+    path.join(homeDir, '.codegraph', 'current', 'bin', 'codegraph'),
+  ]
+}
+
+function resolveCodeGraphBin(options = {}) {
   if (process.env.CODEGRAPH_INSTALL_BIN) {
     return {
       command: process.env.CODEGRAPH_INSTALL_BIN,
       argsPrefix: [],
       displayCommand: process.env.CODEGRAPH_INSTALL_BIN,
+      source: 'env',
     }
   }
 
-  let packageJsonPath
-  try {
-    packageJsonPath = require.resolve('@colbymchenry/codegraph/package.json')
-  } catch (error) {
-    throw new Error(
-      'Unable to resolve @colbymchenry/codegraph. Run npm install before applying the CodeGraph integration.'
-    )
+  if (process.env.CODEGRAPH_INSTALL_FORCE_STANDALONE === '1' && !options.ignoreForceStandalone) {
+    return null
+  }
+
+  const pathCandidate = findOnPath('codegraph', options)
+  if (pathCandidate) {
+    return {
+      command: pathCandidate,
+      argsPrefix: [],
+      displayCommand: pathCandidate,
+      source: 'path',
+    }
+  }
+
+  for (const candidate of defaultCodeGraphCandidates(options)) {
+    if (canExecute(candidate)) {
+      return {
+        command: candidate,
+        argsPrefix: [],
+        displayCommand: candidate,
+        source: 'default-location',
+      }
+    }
+  }
+
+  return null
+}
+
+function resolvePowerShellCommand() {
+  return findOnPath('powershell.exe') || findOnPath('powershell') || findOnPath('pwsh') || 'powershell.exe'
+}
+
+function buildStandaloneInstallerInfo(platform = process.platform) {
+  if (platform === 'darwin' || platform === 'linux') {
+    return {
+      supported: true,
+      platform,
+      display: `curl -fsSL ${INSTALL_SH_URL} -o "$TMPDIR/codegraph-install.sh" && sh "$TMPDIR/codegraph-install.sh"`,
+      requiredCommand: 'curl',
+      url: INSTALL_SH_URL,
+    }
+  }
+
+  if (platform === 'win32') {
+    return {
+      supported: true,
+      platform,
+      display: `irm ${INSTALL_PS1_URL} | iex`,
+      requiredCommand: resolvePowerShellCommand(),
+      url: INSTALL_PS1_URL,
+    }
   }
 
-  const binPath = path.join(path.dirname(packageJsonPath), 'dist', 'bin', 'codegraph.js')
   return {
-    command: process.execPath,
-    argsPrefix: [binPath],
-    displayCommand: `${process.execPath} ${binPath}`,
+    supported: false,
+    platform,
+    display: '',
+    requiredCommand: '',
+    url: '',
+    reason: `CodeGraph standalone installer does not support platform: ${platform}`,
   }
 }
 
@@ -88,27 +208,101 @@ function buildInstallCommand(target) {
 
   const resolved = resolveCodeGraphBin()
   const args = [
-    ...resolved.argsPrefix,
+    ...(resolved ? resolved.argsPrefix : []),
     'install',
     `--target=${mappedTarget}`,
     '--location=global',
     '--yes',
   ]
+  const displayCommand = resolved ? resolved.displayCommand : 'codegraph'
 
   return {
     supported: true,
     target: mappedTarget,
+    command: resolved ? resolved.command : null,
+    args,
+    display: [displayCommand, ...args.slice(resolved ? resolved.argsPrefix.length : 0)].join(' '),
+    needsBootstrap: !resolved,
+    bootstrap: buildStandaloneInstallerInfo(),
+    binarySource: resolved ? resolved.source : null,
+  }
+}
+
+function spawnChecked(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || process.cwd(),
+    env: options.env || process.env,
+    encoding: 'utf8',
+    stdio: options.stdio || ['inherit', process.stderr, process.stderr],
+    timeout: options.timeout,
+  })
+
+  return typeof result.status === 'number' ? result.status : 1
+}
+
+function runStandaloneInstaller() {
+  const installer = buildStandaloneInstallerInfo()
+  if (!installer.supported) {
+    throw new Error(installer.reason)
+  }
+
+  if (installer.platform === 'darwin' || installer.platform === 'linux') {
+    const curl = findOnPath('curl') || 'curl'
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-install-'))
+    const scriptPath = path.join(tempDir, 'install.sh')
+    try {
+      let status = spawnChecked(curl, ['-fsSL', INSTALL_SH_URL, '-o', scriptPath])
+      if (status !== 0) {
+        return status
+      }
+      status = spawnChecked('sh', [scriptPath])
+      return status
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  }
+
+  return spawnChecked(resolvePowerShellCommand(), [
+    '-NoProfile',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-Command',
+    `irm ${INSTALL_PS1_URL} | iex`,
+  ])
+}
+
+function buildTargetInstallInvocation(target) {
+  const mappedTarget = mapTarget(target)
+  const resolved = resolveCodeGraphBin({ ignoreForceStandalone: true })
+  if (!mappedTarget || !resolved) {
+    return null
+  }
+
+  const args = [
+    ...resolved.argsPrefix,
+    'install',
+    `--target=${mappedTarget}`,
+    '--location=global',
+    '--yes',
+  ]
+
+  return {
     command: resolved.command,
     args,
-    display: [resolved.displayCommand, ...args.slice(resolved.argsPrefix.length)].join(' '),
   }
 }
 
 function printHelp() {
   console.log(`Usage: node scripts/install-codegraph.js [--target <claude|codex|cursor|opencode>] [--dry-run]
 
-Runs the upstream CodeGraph installer for the current TSP install target only.
-The project index is not initialized here; run codegraph init -i inside a target project when needed.
+Installs the standalone CodeGraph CLI with the official upstream curl/PowerShell installer when needed,
+then configures CodeGraph for the current TSP install target only.
+
+Environment:
+  CODEGRAPH_INSTALL_BIN=<path>         Use an existing CodeGraph binary, including offline installs.
+  CODEGRAPH_INSTALL_FORCE_STANDALONE=1 Re-run the official standalone installer before target config.
+
+Project indexes are created by the Claude SessionStart auto-init hook or by running codegraph init -i.
 `)
 }
 
@@ -126,19 +320,31 @@ function run(argv = process.argv.slice(2)) {
   }
 
   if (options.dryRun) {
-    console.log(`CodeGraph install command: ${install.display}`)
+    if (install.needsBootstrap) {
+      console.log(`CodeGraph standalone install command: ${install.bootstrap.display}`)
+    } else {
+      console.log(`CodeGraph binary: ${install.command} (${install.binarySource})`)
+    }
+    console.log(`CodeGraph target install command: ${install.display}`)
     return 0
   }
 
-  console.error(`Running CodeGraph installer for ${install.target}`)
-  const result = spawnSync(install.command, install.args, {
-    cwd: process.cwd(),
-    env: process.env,
-    encoding: 'utf8',
-    stdio: ['inherit', process.stderr, process.stderr],
-  })
+  if (install.needsBootstrap) {
+    console.error('Installing CodeGraph standalone CLI with the official upstream installer')
+    const bootstrapStatus = runStandaloneInstaller()
+    if (bootstrapStatus !== 0) {
+      return bootstrapStatus
+    }
+  }
 
-  return typeof result.status === 'number' ? result.status : 1
+  const invocation = buildTargetInstallInvocation(install.target)
+  if (!invocation) {
+    console.error('CodeGraph binary is still unavailable after standalone install. Add it to PATH or set CODEGRAPH_INSTALL_BIN.')
+    return 1
+  }
+
+  console.error(`Running CodeGraph installer for ${install.target}`)
+  return spawnChecked(invocation.command, invocation.args)
 }
 
 if (require.main === module) {
@@ -152,7 +358,11 @@ if (require.main === module) {
 
 module.exports = {
   buildInstallCommand,
+  buildStandaloneInstallerInfo,
+  defaultCodeGraphCandidates,
+  findOnPath,
   mapTarget,
   parseArgs,
+  resolveCodeGraphBin,
   run,
 }

package/scripts/install-plan.js

@@ -156,6 +156,8 @@ function resolvePlanExternalInstalls(plan) {
       args: Array.isArray(externalInstall.args)
         ? externalInstall.args.map(value => String(value))
         : [],
+      failureMode: externalInstall.failureMode === 'warn' ? 'warn' : 'error',
+      failureHint: typeof externalInstall.failureHint === 'string' ? externalInstall.failureHint : '',
       target: plan.target || null,
       profileId: plan.profileId || null,
     }));
@@ -213,7 +215,8 @@ function printPlan(plan) {
     console.log('');
     console.log(`External install plan (${externalInstalls.length}):`);
     for (const externalInstall of externalInstalls) {
-      console.log(`- ${externalInstall.id}: ${externalInstall.description || externalInstall.script}`);
+      const mode = externalInstall.failureMode === 'warn' ? ' [warn-on-failure]' : '';
+      console.log(`- ${externalInstall.id}${mode}: ${externalInstall.description || externalInstall.script}`);
     }
   }
 }

package/scripts/lib/install/apply.js

@@ -219,6 +219,11 @@ function runExternalInstall(externalInstall) {
   });
 
   if (result.status !== 0) {
+    if (externalInstall.failureMode === 'warn') {
+      console.error(`Warning: optional external install failed: ${label}`);
+      console.error(externalInstall.failureHint || 'TSP core install will continue; rerun when the external dependency is reachable.');
+      return;
+    }
     throw new Error(`External install failed: ${label}`);
   }
 }