sap-ai-dev-toolkit 0.9.9904 → 0.9.9908

package/src/abaplint.mjs

@@ -1,5 +1,13 @@
+import { lstat, readdir, readFile, realpath } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { Config, MemoryFile, Registry } from '@abaplint/core';
 
+const MAX_PROJECT_FILES = 20_000;
+const MAX_PROJECT_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_PROJECT_SOURCE_BYTES = 32 * 1024 * 1024;
+const IGNORED_DIRECTORIES = new Set(['.git', '.hg', '.svn', '.build', '.next', '.cache', 'coverage', 'dist', 'node_modules']);
+const PROJECT_CONFIG_FILES = ['.abaplint.jsonc', 'abaplint.jsonc', '.abaplint.json', 'abaplint.json'];
+
 export const ABAP_LINT_TOOL = {
   name: 'LintABAP',
   description: 'Run abaplint on caller-supplied source files in memory; does not read workspace files or call SAP.',
@@ -26,6 +34,21 @@ export const ABAP_LINT_TOOL = {
   }
 };
 
+export const ABAP_LINT_PROJECT_TOOL = {
+  name: 'LintABAPProject',
+  description: 'Run read-only abaplint checks over serialized ABAP objects under the configured workspace root. Loads the project config and local dependency folders when present; does not call SAP, write files, or activate ABAP.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      directory: { type: 'string', description: 'Optional project subdirectory relative to the configured workspace root.' },
+      config: { type: 'object', description: 'Optional abaplint config object that overrides project config discovery.' }
+    },
+    required: [],
+    additionalProperties: false
+  },
+  annotations: { readOnlyHint: true }
+};
+
 function isObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -65,6 +88,170 @@ function errorResult(error) {
   };
 }
 
+function reportResult(report) {
+  return {
+    isError: false,
+    content: [{ type: 'text', text: JSON.stringify(report) }],
+    structuredContent: report
+  };
+}
+
+function lintReport(registry, filesChecked) {
+  const issues = registry.findIssues();
+  const counts = { Error: 0, Warning: 0, Info: 0 };
+  const reportIssues = issues.map(issue => {
+    counts[issue.getSeverity()] += 1;
+    const start = issue.getStart();
+    const end = issue.getEnd();
+    return {
+      filename: issue.getFilename(),
+      rule: issue.getKey(),
+      severity: issue.getSeverity(),
+      message: issue.getMessage(),
+      start: { line: start.getRow(), column: start.getCol() },
+      end: { line: end.getRow(), column: end.getCol() }
+    };
+  });
+  return {
+    status: reportIssues.length === 0 ? 'clean' : 'issues',
+    filesChecked,
+    issueCount: reportIssues.length,
+    errors: counts.Error,
+    warnings: counts.Warning,
+    infos: counts.Info,
+    issues: reportIssues
+  };
+}
+
+function pathIsWithin(parent, candidate) {
+  const path = relative(parent, candidate);
+  return path === '' || (path !== '..' && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+
+function validateProjectArguments(arguments_) {
+  if (!isObject(arguments_)) throw new Error('Arguments must be an object');
+  rejectUnknownFields(arguments_, new Set(['directory', 'config']), 'argument');
+  if (arguments_.directory !== undefined) {
+    if (typeof arguments_.directory !== 'string' || arguments_.directory.includes('\0') ||
+        isAbsolute(arguments_.directory) || /^[A-Za-z]:[\\/]/.test(arguments_.directory) ||
+        arguments_.directory.split(/[\\/]+/).includes('..')) {
+      throw new Error('directory must be a relative path inside the configured workspace root');
+    }
+  }
+  if (arguments_.config !== undefined && !isObject(arguments_.config)) {
+    throw new Error('config must be an object');
+  }
+}
+
+async function loadProjectConfig(directory, override) {
+  if (override !== undefined) return { config: new Config(JSON.stringify(override)), source: 'caller' };
+  for (const filename of PROJECT_CONFIG_FILES) {
+    const configPath = resolve(directory, filename);
+    let info;
+    try { info = await lstat(configPath); }
+    catch (error) {
+      if (error?.code === 'ENOENT') continue;
+      throw error;
+    }
+    if (info.isSymbolicLink() || !info.isFile()) throw new Error(`${filename} must be a regular file inside the workspace`);
+    try {
+      return { config: new Config(await readFile(configPath, 'utf8')), source: filename };
+    } catch (error) {
+      throw new Error(`Could not load ${filename}: ${error.message || error}`);
+    }
+  }
+  return { config: Config.getDefault(), source: 'default' };
+}
+
+function enableSyntaxRules(config) {
+  const projectConfig = config.get();
+  const rules = { ...(projectConfig.rules || {}) };
+  const disabled = [];
+  for (const rule of ['parser_error', 'check_syntax']) {
+    if (rules[rule] === false) disabled.push(rule);
+    else if (rules[rule] === undefined) rules[rule] = true;
+  }
+  return {
+    config: new Config(JSON.stringify({ ...projectConfig, rules })),
+    disabled
+  };
+}
+
+async function dependencyRoots(config, projectRoot) {
+  const declared = config.get()?.dependencies;
+  if (!Array.isArray(declared)) return { roots: [], missing: [], count: 0 };
+  const roots = [];
+  const missing = [];
+  for (const dependency of declared) {
+    const folder = dependency?.folder;
+    if (typeof folder !== 'string' || !folder.trim()) {
+      missing.push(String(folder || '(unspecified folder)'));
+      continue;
+    }
+    const relativeFolder = folder.replace(/^[\\/]+/, '');
+    if (/^[A-Za-z]:[\\/]/.test(relativeFolder) || relativeFolder.split(/[\\/]+/).includes('..')) {
+      throw new Error('Dependency folders must stay inside the configured project directory');
+    }
+    const candidate = resolve(projectRoot, relativeFolder || '.');
+    if (!pathIsWithin(projectRoot, candidate)) throw new Error('Dependency folders must stay inside the configured project directory');
+    let canonical;
+    try { canonical = await realpath(candidate); }
+    catch (error) {
+      if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') {
+        missing.push(folder);
+        continue;
+      }
+      throw error;
+    }
+    if (!pathIsWithin(projectRoot, canonical)) throw new Error('Dependency folders must stay inside the configured project directory');
+    const info = await lstat(canonical);
+    if (!info.isDirectory()) {
+      missing.push(folder);
+      continue;
+    }
+    roots.push(canonical);
+  }
+  return { roots, missing, count: declared.length };
+}
+
+async function collectProjectFiles(projectRoot, dependencies) {
+  const sourceFiles = [];
+  const dependencyFiles = [];
+  const pending = [projectRoot];
+  let totalBytes = 0;
+  while (pending.length) {
+    const directory = pending.pop();
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const absolutePath = resolve(directory, entry.name);
+      if (entry.isDirectory()) {
+        const isDependencyPath = dependencies.some(root => pathIsWithin(absolutePath, root) || pathIsWithin(root, absolutePath));
+        if (!IGNORED_DIRECTORIES.has(entry.name) || isDependencyPath) pending.push(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const filename = relative(projectRoot, absolutePath).split(sep).join('/');
+      const basename = filename.split('/').at(-1);
+      const nameParts = basename.split('.');
+      if (nameParts.length < 3 || !nameParts[0] || !nameParts[1]) continue;
+      if (!new MemoryFile(filename, '').getObjectType()) continue;
+      const info = await lstat(absolutePath);
+      if (!info.isFile() || info.isSymbolicLink()) continue;
+      if (info.size > MAX_PROJECT_FILE_BYTES) throw new Error(`ABAP file exceeds ${MAX_PROJECT_FILE_BYTES} bytes: ${filename}`);
+      totalBytes += info.size;
+      if (totalBytes > MAX_PROJECT_SOURCE_BYTES) throw new Error(`Workspace ABAP sources exceed ${MAX_PROJECT_SOURCE_BYTES} bytes`);
+      const file = new MemoryFile(filename, await readFile(absolutePath, 'utf8'));
+      const isDependency = dependencies.some(root => pathIsWithin(root, absolutePath));
+      (isDependency ? dependencyFiles : sourceFiles).push(file);
+      if (sourceFiles.length + dependencyFiles.length > MAX_PROJECT_FILES) {
+        throw new Error(`Workspace contains more than ${MAX_PROJECT_FILES} ABAP files`);
+      }
+    }
+  }
+  return { sourceFiles, dependencyFiles };
+}
+
 export async function runABAPLint(arguments_) {
   try {
     validateArguments(arguments_);
@@ -74,31 +261,49 @@ export async function runABAPLint(arguments_) {
     const files = arguments_.files.map(({ filename, source }) => new MemoryFile(filename, source));
     const registry = new Registry(config).addFiles(files);
     await registry.parseAsync();
-    const issues = registry.findIssues();
-    const counts = { Error: 0, Warning: 0, Info: 0 };
-    const reportIssues = issues.map(issue => {
-      counts[issue.getSeverity()] += 1;
-      const start = issue.getStart();
-      const end = issue.getEnd();
-      return {
-        filename: issue.getFilename(),
-        rule: issue.getKey(),
-        severity: issue.getSeverity(),
-        message: issue.getMessage(),
-        start: { line: start.getRow(), column: start.getCol() },
-        end: { line: end.getRow(), column: end.getCol() }
-      };
+    return { isError: false, content: [{ type: 'text', text: JSON.stringify(lintReport(registry, files.length)) }] };
+  } catch (error) {
+    return errorResult(error);
+  }
+}
+
+export async function runABAPLintProject(arguments_, { workspaceRoot = process.cwd() } = {}) {
+  try {
+    validateProjectArguments(arguments_);
+    const root = await realpath(workspaceRoot);
+    const directory = resolve(root, arguments_.directory || '.');
+    if (!pathIsWithin(root, directory)) throw new Error('directory must stay inside the configured workspace root');
+    const projectRoot = await realpath(directory);
+    if (!pathIsWithin(root, projectRoot)) throw new Error('directory must stay inside the configured workspace root');
+    const projectInfo = await lstat(projectRoot);
+    if (!projectInfo.isDirectory()) throw new Error('directory must identify a workspace directory');
+
+    const { config: projectConfig, source: configSource } = await loadProjectConfig(projectRoot, arguments_.config);
+    const { config, disabled: disabledSyntaxRules } = enableSyntaxRules(projectConfig);
+    const dependencies = await dependencyRoots(config, projectRoot);
+    const { sourceFiles, dependencyFiles } = await collectProjectFiles(projectRoot, dependencies.roots);
+    const registry = new Registry(config);
+    registry.addDependencies(dependencyFiles);
+    registry.addFiles(sourceFiles);
+    await registry.parseAsync();
+
+    const report = lintReport(registry, sourceFiles.length);
+    if (report.filesChecked === 0) report.status = 'no-abap-files';
+    else if (report.status === 'clean' && (dependencies.missing.length || disabledSyntaxRules.length)) report.status = 'incomplete';
+    return reportResult({
+      ...report,
+      scope: 'workspace-static',
+      activation: 'not-performed',
+      workspaceDirectory: arguments_.directory || '.',
+      configSource,
+      targetRelease: config.getVersion(),
+      syntaxRules: { enabled: ['parser_error', 'check_syntax'].filter(rule => !disabledSyntaxRules.includes(rule)), disabled: disabledSyntaxRules },
+      dependencies: {
+        declared: dependencies.count,
+        filesLoaded: dependencyFiles.length,
+        missingFolders: dependencies.missing
+      }
     });
-    const report = {
-      status: reportIssues.length === 0 ? 'clean' : 'issues',
-      filesChecked: files.length,
-      issueCount: reportIssues.length,
-      errors: counts.Error,
-      warnings: counts.Warning,
-      infos: counts.Info,
-      issues: reportIssues
-    };
-    return { isError: false, content: [{ type: 'text', text: JSON.stringify(report) }] };
   } catch (error) {
     return errorResult(error);
   }

package/src/harness-mcp-config.mjs

@@ -7,7 +7,7 @@ import { decodeJsonFileBuffer } from './mcp-config.mjs';
 
 const MANAGED_ENV = 'SAP_AI_DEV_TOOLKIT_MANAGED';
 
-function mcpServersPath(harness, { home = process.env.HOME || homedir(), env = process.env } = {}) {
+function mcpServersPath(harness, { home = process.env.HOME || homedir(), env = process.env, platform = process.platform } = {}) {
   switch (harness.id) {
     case 'claude-code':
       return join(home, '.claude.json');
@@ -15,8 +15,16 @@ function mcpServersPath(harness, { home = process.env.HOME || homedir(), env = p
       return join(harnessRoot(harness, { home, env }), 'mcp.json');
     case 'gemini-cli':
       return join(harnessRoot(harness, { home, env }), 'settings.json');
+    case 'omp':
+      return join(harnessRoot(harness, { home, env }), 'mcp.json');
     case 'pi-coding-agent':
       return join(harnessRoot(harness, { home, env }), 'mcp.json');
+    case 'windsurf': {
+      const configRoot = platform === 'win32'
+        ? (typeof env?.APPDATA === 'string' && env.APPDATA.trim() ? env.APPDATA.trim() : join(home, 'AppData', 'Roaming'))
+        : (typeof env?.XDG_CONFIG_HOME === 'string' && env.XDG_CONFIG_HOME.trim() ? env.XDG_CONFIG_HOME.trim() : join(home, '.config'));
+      return join(configRoot, 'devin', 'mcp_config.json');
+    }
     default:
       return null;
   }

package/src/harness-setup.mjs

@@ -0,0 +1,202 @@
+import { open } from 'node:fs/promises';
+import { closeSync, openSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { ReadStream as TTYReadStream, WriteStream as TTYWriteStream } from 'node:tty';
+import { installMcpServersForHarnesses } from './harness-mcp-config.mjs';
+import { installUserAssetsForHarnesses } from './install-user-assets.mjs';
+import { DEFAULT_HARNESS_IDS, HARNESSES, HARNESS_ENV_VAR, NON_INTERACTIVE_HARNESS_IDS, envHarnessSelection, harnessRoot } from './harnesses.mjs';
+import { checkboxPrompt, colorText, formatStatus } from './terminal-ui.mjs';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+export async function announce(message, tone = 'info') {
+  const content = message.replace(/^sap-ai-dev-toolkit:\s*/, '');
+  // Windows cannot open CONOUT$ as a writable console stream from a
+  // piped npm script (libuv normalizes the device name, and the resulting
+  // handle drops writes), so output goes through stderr unconditionally.
+  if (process.platform === 'win32') {
+    console.error(formatStatus(content, tone, process.stderr));
+    return;
+  }
+  let terminal;
+  try {
+    terminal = await open('/dev/tty', 'w');
+    await terminal.write(`${formatStatus(content, tone, true)}\n`);
+  } catch {
+    console.error(formatStatus(content, tone, process.stderr));
+  } finally {
+    await terminal?.close().catch(() => {});
+  }
+}
+
+function openControllingTerminal() {
+  if (process.platform === 'win32') {
+    // npm can pipe lifecycle script streams even when the install was
+    // launched from an interactive Windows console. Verify console access,
+    // then attach Node TTY streams to its standard console devices.
+    const probe = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '[Console]::OpenStandardInput(); [Console]::OpenStandardOutput()'], { stdio: 'ignore', windowsHide: true });
+    if (probe.error || probe.status !== 0) throw new Error('interactive console is unavailable');
+    const inputFd = openSync('CONIN$', 'r');
+    let outputFd;
+    try {
+      outputFd = openSync('CONOUT$', 'w');
+      return { input: new TTYReadStream(inputFd), output: new TTYWriteStream(outputFd) };
+    } catch (error) {
+      closeSync(inputFd);
+      if (outputFd !== undefined) closeSync(outputFd);
+      throw error;
+    }
+  }
+  const inputFd = openSync('/dev/tty', 'r');
+  let outputFd;
+  try {
+    outputFd = openSync('/dev/tty', 'w');
+    return { input: new TTYReadStream(inputFd), output: new TTYWriteStream(outputFd) };
+  } catch (error) {
+    closeSync(inputFd);
+    if (outputFd !== undefined) closeSync(outputFd);
+    throw error;
+  }
+}
+
+export async function withInstallTerminal(action) {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    return action({ input: process.stdin, output: process.stdout });
+  }
+  let terminal;
+  try {
+    terminal = openControllingTerminal();
+  } catch {
+    return action(null);
+  }
+  try {
+    return await action(terminal);
+  } finally {
+    terminal.input.destroy();
+    terminal.output.destroy();
+  }
+}
+
+function harnessSelectionLabels(ids) {
+  return HARNESSES.filter(harness => ids.includes(harness.id)).map(harness => harness.label).join(', ');
+}
+
+async function resolveHarnessOverride(env) {
+  try {
+    return envHarnessSelection(env);
+  } catch (error) {
+    await announce(`${error.message} Ignoring ${HARNESS_ENV_VAR}.`, 'warning');
+    return null;
+  }
+}
+
+async function installSelectedHarnessAssets(ids, { env, home, root }) {
+  const { results, failures } = await installUserAssetsForHarnesses(ids, { env, home, root });
+  for (const failure of failures) {
+    await announce(`${failure.label}: bundled agent and skill installation failed: ${failure.error.message}`, 'error');
+  }
+  for (const assets of results) {
+    const installed = assets.installed + assets.updated;
+    const removed = assets.removed || 0;
+    const cleanup = removed > 0 ? `; ${removed} duplicate or legacy file${removed === 1 ? '' : 's'} removed` : '';
+    await announce(`${assets.label}: ${installed} file${installed === 1 ? '' : 's'} installed or updated in ${assets.root}; ${assets.unchanged} already current${cleanup}.`, 'success');
+    if (assets.conflicts.length > 0) {
+      const paths = assets.conflicts.map(path => join(assets.root, path)).join(', ');
+      await announce(`${assets.label}: existing customizations were preserved; review these paths: ${paths}`, 'warning');
+    }
+  }
+  const total = results.reduce((sum, assets) => sum + assets.installed + assets.updated, 0);
+  if (results.length > 0) {
+    await announce(`Installed ${total} files across ${results.length} harness${results.length === 1 ? '' : 'es'}.`, 'success');
+  }
+}
+
+async function runHarnessAssetInstall({ env = process.env, root = packageRoot } = {}) {
+  const home = env.HOME || homedir();
+  const override = await resolveHarnessOverride(env);
+  return withInstallTerminal(async terminal => {
+    let selected = override;
+    if (!terminal) {
+      if (!selected) selected = NON_INTERACTIVE_HARNESS_IDS;
+      await announce(`Installing bundled agents and skills for ${harnessSelectionLabels(selected)} by default because no interactive terminal is available.`, 'progress');
+      await installSelectedHarnessAssets(selected, { env, home, root });
+      return selected;
+    }
+    if (!selected) selected = DEFAULT_HARNESS_IDS;
+    await announce([
+      'The bundled agents and skills can be installed for several AI coding harnesses.',
+      '',
+      'Space = select or deselect · a = toggle all · Enter = confirm. Pressing Enter without changes installs the pre-checked harnesses; confirming with none selected skips this step.',
+      '',
+      `${colorText('📁 Target folders:', 'cyan', true)}`,
+      ...HARNESSES.map(harness => `   ${harnessRoot(harness, { home, env })} — ${harness.label} (${harness.supportsAgents ? 'skills + agents' : 'skills only'})`),
+      ''
+    ].join('\n'), 'copilot');
+    let answer;
+    try {
+      answer = await checkboxPrompt({
+        message: colorText('🤖 Install bundled agents and skills for', 'magenta', terminal.output),
+        choices: HARNESSES.map(harness => ({
+          value: harness.id,
+          name: `${harness.label} (${harness.supportsAgents ? 'skills + agents' : 'skills'})`,
+          checked: selected.includes(harness.id)
+        })),
+        required: false,
+        shortcuts: { all: 'a' }
+      }, { input: terminal.input, output: terminal.output });
+    } catch (error) {
+      if (error.message === 'Prompt interrupted') {
+        await announce('Bundled agents and skills were skipped because the prompt was interrupted. Your files were not changed.', 'info');
+        return [];
+      }
+      throw error;
+    }
+    if (answer.length === 0) {
+      await announce('Bundled agents and skills were skipped. Your files were not changed.', 'info');
+      return [];
+    }
+    await installSelectedHarnessAssets(answer, { env, home, root });
+    return answer;
+  });
+}
+
+async function wireHarnessMcpServers(ids, servers, env) {
+  const entries = servers && Object.keys(servers).length ? servers : null;
+  if (!entries || !ids?.length) return;
+  const hasLocalSapGui = Object.values(entries).some(entry => entry?.env?.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE === 'sap-gui-local');
+  if (hasLocalSapGui) {
+    await announce('Local SAP GUI MCP entries use VS Code input prompts for SAP login, so automatic wiring into non-VS Code harness MCP files was skipped. Configure those harnesses manually if they support secure runtime prompts.', 'info');
+    return;
+  }
+  const { results, failures } = await installMcpServersForHarnesses(ids, entries, { env });
+  for (const result of results) {
+    if (!result.supported) {
+      await announce(`${result.label}: MCP auto-wiring skipped. ${result.skipped}`, 'info');
+      continue;
+    }
+    await announce(`${result.label}: wired ${result.servers} MCP server${result.servers === 1 ? '' : 's'} in ${result.path}.`, 'success');
+  }
+  for (const failure of failures) {
+    await announce(`${failure.label}: MCP auto-wiring failed: ${failure.error.message}`, 'error');
+  }
+}
+
+export async function runHarnessSetup(servers, { env = process.env, root = packageRoot, wire = true } = {}) {
+  let ids = [];
+  try {
+    ids = await runHarnessAssetInstall({ env, root });
+  } catch (error) {
+    await announce(`Bundled agent and skill installation failed: ${error.message}`, 'error');
+  }
+  if (wire) {
+    try {
+      await wireHarnessMcpServers(ids, servers, env);
+    } catch (error) {
+      await announce(`Harness MCP auto-wiring failed: ${error.message}`, 'error');
+    }
+  }
+  return ids;
+}

package/src/harnesses.mjs

@@ -1,5 +1,5 @@
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 
 export const HARNESS_ENV_VAR = 'SAP_AI_DEV_TOOLKIT_HARNESSES';
 export const DEFAULT_HARNESS_IDS = ['github-copilot', 'claude-code'];
@@ -38,6 +38,19 @@ export function piCodingAgentRoot({ home = process.env.HOME || homedir(), env =
   return override || join(home, '.pi', 'agent');
 }
 
+export function ompAgentRoot({ home = process.env.HOME || homedir(), env = process.env } = {}) {
+  const agentOverride = typeof env?.PI_CODING_AGENT_DIR === 'string' ? env.PI_CODING_AGENT_DIR.trim() : '';
+  if (agentOverride) return resolve(agentOverride);
+  const configDirectory = typeof env?.PI_CONFIG_DIR === 'string' ? env.PI_CONFIG_DIR.trim() : '';
+  return join(home, configDirectory || '.omp', 'agent');
+}
+
+export function windsurfSkillsRoot({ home = process.env.HOME || homedir(), env = process.env, platform = process.platform } = {}) {
+  if (platform === 'win32') return join(home, '.codeium', 'windsurf');
+  const override = typeof env?.XDG_CONFIG_HOME === 'string' ? env.XDG_CONFIG_HOME.trim() : '';
+  return join(override || join(home, '.config'), 'devin');
+}
+
 export function claudeCodeAgentDocument(source) {
   const frontmatter = splitFrontmatter(source);
   if (!frontmatter) throw new Error('unsupported agent frontmatter');
@@ -86,7 +99,11 @@ export const HARNESSES = [
   { id: 'cursor', label: 'Cursor', directory: '.cursor', supportsAgents: false },
   { id: 'gemini-cli', label: 'Gemini CLI', directory: '.gemini', supportsAgents: false },
   { id: 'opencode', label: 'opencode', directory: 'opencode', configHome: true, supportsAgents: true, agentFileName: agentMarkdownName, agentDocument: opencodeAgentDocument },
-  { id: 'pi-coding-agent', label: 'Pi Coding Agent', directory: '.pi/agent', supportsAgents: true, agentTargetPrefix: 'prompts', agentFileName: agentMarkdownName, agentDocument: piCodingAgentPromptDocument, root: piCodingAgentRoot }
+  { id: 'pi-coding-agent', label: 'Pi Coding Agent', directory: '.pi/agent', supportsAgents: true, agentTargetPrefix: 'prompts', agentFileName: agentMarkdownName, agentDocument: piCodingAgentPromptDocument, root: piCodingAgentRoot },
+  { id: 'omp', label: 'Oh My Pi (OMP)', directory: '.omp/agent', supportsAgents: false, root: ompAgentRoot },
+  { id: 'cline', label: 'Cline', directory: '.cline', supportsAgents: false },
+  { id: 'roo-code', label: 'Roo Code', directory: '.roo', supportsAgents: false },
+  { id: 'windsurf', label: 'Windsurf / Devin Desktop', directory: 'devin', supportsAgents: false, root: windsurfSkillsRoot }
 ];
 
 export function harnessById(id) {
@@ -97,8 +114,8 @@ export function harnessById(id) {
   return harness;
 }
 
-export function harnessRoot(harness, { home = process.env.HOME || homedir(), env = process.env } = {}) {
-  if (harness.root) return harness.root({ home, env });
+export function harnessRoot(harness, { home = process.env.HOME || homedir(), env = process.env, platform = process.platform } = {}) {
+  if (harness.root) return harness.root({ home, env, platform });
   if (harness.configHome) {
     const override = typeof env?.XDG_CONFIG_HOME === 'string' ? env.XDG_CONFIG_HOME.trim() : '';
     return join(override || join(home, '.config'), harness.directory);

package/src/launcher.mjs

@@ -11,6 +11,7 @@ import { binaryTarget, cacheDirectory, downloadBinary, findBinary } from './bina
 import { MCPProxy } from './mcp-proxy.mjs';
 import { configuredVersionHandoff, installMcpConfig, npxPackageLauncher, repairManagedMcpConfig } from './mcp-config.mjs';
 import { runSetup } from './setup.mjs';
+import { runHarnessSetup } from './harness-setup.mjs';
 import { resolveConfiguredCloudFoundryDestination } from './cf-destination.mjs';
 import { createTlsServerNameAdtProxy } from './tls-adt-proxy.mjs';
 import { findSsoBrowsers } from './sso-browsers.mjs';
@@ -106,7 +107,7 @@ async function runDoctor(destinations) {
       // unprefixed (get_source, run_query); match the slug-prefixed form too
       // in case this ever runs against a multi-destination server.
       const toolPrefix = `${slugifyDestination(destination.name)}_`;
-      const localSegments = new Set(['lint_abap', 'get_application_log', 'prepare_abap_change_set', 'apply_abap_change_set', 'check_transport_readiness', 'plan_abap_cloud_migration', 'generate_rap_regression_suite', 'run_rap_regression_suite']);
+      const localSegments = new Set(['lint_abap', 'lint_abap_project', 'get_application_log', 'prepare_abap_change_set', 'apply_abap_change_set', 'check_transport_readiness', 'plan_abap_cloud_migration', 'generate_rap_regression_suite', 'run_rap_regression_suite']);
       const isUpstreamTool = tool => (tool.name.startsWith(toolPrefix) ? tool.name.slice(toolPrefix.length) : tool.name);
       const upstreamCount = tools.filter(tool => !localSegments.has(isUpstreamTool(tool))).length;
       checks.push(doctorRow(destination.name, 'MCP tools/list', upstreamCount ? 'passed' : 'failed', `${upstreamCount} upstream tools and ${tools.length} total MCP tools returned; chat-picker binding is host-managed`));
@@ -415,7 +416,8 @@ async function main() {
       const launcher = npxPackageLauncher(pkg.version);
       setupOptions.install = (selected, options) => installMcpConfig(selected, { ...options, ...launcher });
     }
-    await runSetup(setupOptions);
+    const result = await runSetup(setupOptions);
+    await runHarnessSetup(result?.servers, { env: runtimeEnv, root });
     return;
   }
   if (check || list) {
@@ -460,7 +462,8 @@ async function main() {
   if (!runtimeEnv.H2O_URL) {
     if (args().length === 0 && process.stdin.isTTY && process.stdout.isTTY) {
       console.error('sap-ai-dev: no BAS environment detected; starting local interactive setup. Use --help for other commands.');
-      await runSetup({ detectAdtUrl: detectLocalAdtUrl });
+      const result = await runSetup({ detectAdtUrl: detectLocalAdtUrl });
+      await runHarnessSetup(result?.servers, { env: runtimeEnv, root });
       return;
     }
     const binary = await binaryOrError();

package/src/mcp-proxy.mjs

@@ -1,7 +1,7 @@
 import { spawn as nodeSpawn } from 'node:child_process';
 import { once } from 'node:events';
 import { sanitizeChildEnv, slugifyDestination } from './bas-discovery.mjs';
-import { ABAP_LINT_TOOL, runABAPLint } from './abaplint.mjs';
+import { ABAP_LINT_PROJECT_TOOL, ABAP_LINT_TOOL, runABAPLint, runABAPLintProject } from './abaplint.mjs';
 import { createEngineeringTools } from './engineering-tools.mjs';
 import { brandedEnvValue } from './branding.mjs';
 import { diagnosticText, redactText } from './redact.mjs';
@@ -698,6 +698,12 @@ export class MCPProxy {
         });
       }
     }
+    const projectLintName = snakeCaseName(ABAP_LINT_PROJECT_TOOL.name);
+    publish(projectLintName, {
+      handler: arguments_ => runABAPLintProject(arguments_, {
+        workspaceRoot: brandedEnvValue(this.env, 'WORKSPACE_ROOT') || process.cwd()
+      })
+    }, { ...ABAP_LINT_PROJECT_TOOL, name: projectLintName });
     if (!merged.length && this.children.length) throw new Error('No destination child provided tools');
     // Swap atomically so a concurrent tools/call never sees a partial map.
     this.namespace = namespace;