abapgit-agent 1.13.7 → 1.14.1

package/README.md

@@ -97,14 +97,17 @@ abapgit-agent health                  # Verify ABAP connection
 
 ```bash
 # Install dependencies
-cd abapgit-agent
 npm install
 
-# Run from package directory (auto-detects from git)
-node bin/abapgit-agent pull
+# Run unit tests (no ABAP system needed)
+npm test
 
-# Or use npm script
-npm run pull -- --url <git-url> --branch main
+# Test a command manually
+node bin/abapgit-agent --help
+node bin/abapgit-agent syntax --files src/zcl_my_class.clas.abap
+
+# Run integration tests against a real ABAP system (requires .abapGitAgent)
+npm run test:integration
 ```
 
 ## Documentation

package/abap/CLAUDE.md

@@ -471,7 +471,7 @@ Run abaplint as step 4b — after `syntax`, before `git commit`:
 
 ```bash
 # Only if .abaplint.json exists
-npx @abaplint/cli .abaplint.json
+abapgit-agent lint
 ```
 
 Fix any reported issues, then commit.
@@ -539,6 +539,21 @@ See **AI Tool Guidelines** below for how to react to each setting.
 ### Branch Workflow (`"mode": "branch"`)
 
 Always work on feature branches. Before every `pull`: rebase to default branch. On completion: create PR with squash merge.
+
+```bash
+git checkout main  # or master/develop (auto-detected)
+git pull origin main
+git checkout -b feature/my-change
+# edit your ABAP file (name from objects.local.md)
+abapgit-agent syntax --files src/<name>.clas.abap
+ls .abaplint.json 2>/dev/null && abapgit-agent lint   # abaplint (if configured)
+git add . && git commit -m "feat: description"
+git push origin feature/my-change
+git fetch origin main && git rebase origin/main
+git push origin feature/my-change --force-with-lease
+abapgit-agent pull --files src/<name>.clas.abap --sync-xml
+```
+
 → See `guidelines/branch-workflow.md` — run: `abapgit-agent ref --topic branch-workflow`
 
 ### Trunk Workflow (`"mode": "trunk"`)
@@ -550,6 +565,7 @@ git checkout main  # or master/develop (auto-detected)
 git pull origin main
 # edit your ABAP file (name from objects.local.md)
 abapgit-agent syntax --files src/<name>.clas.abap
+ls .abaplint.json 2>/dev/null && abapgit-agent lint   # abaplint (if configured)
 git add . && git commit -m "feat: description"
 git push origin main
 abapgit-agent pull --files src/<name>.clas.abap --sync-xml
@@ -649,7 +665,7 @@ Modified ABAP files?
    └─ FUGR and other complex objects?
       └─ ✅ Use: skip syntax → [abaplint] → commit → push → pull --sync-xml → (if errors: inspect)
 
-[abaplint] = run npx @abaplint/cli .abaplint.json only if .abaplint.json exists in repo root
+[abaplint] = run abapgit-agent lint only if .abaplint.json exists in repo root
              before applying any quickfix: run abapgit-agent ref --topic abaplint
 ```
 

package/abap/guidelines/abaplint.md

@@ -9,7 +9,9 @@ grand_parent: ABAP Development
 # abaplint Rule Guidelines
 
 **Searchable keywords**: abaplint, prefer_inline, inline declaration, char literal, string truncation,
-no_inline_in_optional_branches, fully_type_constants, linting, static analysis
+no_inline_in_optional_branches, fully_type_constants, linting, static analysis,
+run abaplint locally, check changed file, abapgit-agent lint,
+keyword_case, sequential_blank, double_space, use_new, local_variable_names
 
 This file covers rules that have **non-obvious or dangerous implications** — cases where applying
 a rule mechanically (or accepting its quickfix) can introduce subtle bugs.
@@ -166,8 +168,57 @@ on rv_result — no intermediate lv_response variable at all.
 
 ---
 
+## Running abaplint Locally Against Changed Files
+
+Run this before pushing to catch issues early, matching what CI does.
+
+```bash
+abapgit-agent lint
+```
+
+This automatically detects changed `.abap` files (via `git diff`), creates a scoped
+abaplint config for just those files, runs the check, and cleans up.
+
+### Options
+
+```bash
+# Diff against a specific base branch (useful on a feature branch)
+abapgit-agent lint --base main
+
+# Check specific files explicitly
+abapgit-agent lint --files src/zcl_foo.clas.abap,src/zcl_foo.clas.testclasses.abap
+
+# Use a different abaplint config (default: .abaplint.json)
+abapgit-agent lint --config .abaplint.json
+```
+
+Run repeatedly after each fix until you see:
+
+```
+abaplint: 0 issue(s) found, 1 file(s) analyzed
+```
+
+---
+
+### Common Issues and Fixes
+
+| Rule | Error message | Fix |
+|------|--------------|-----|
+| `keyword_case` | `Keyword should be upper case: "class"` | Uppercase the keyword: `CLASS` |
+| `sequential_blank` | `Remove sequential blank lines` | Max 1 blank line between blocks |
+| `local_variable_names` | `<fs_data> does not match pattern` | Use `l`-prefixed name: `<ls_data>` |
+| `double_space` | `Remove double space` | Single space around `=` in parameters |
+| `use_new` | `Use NEW #() to instantiate` | Replace `CREATE OBJECT mo_foo` → `mo_foo = NEW #( )` |
+| `method_parameter_names` | `Parameter name does not match pattern` | Use `iv_`, `it_`, `is_`, `io_` etc. prefixes |
+
+See **abaplint-local.md** for the full naming convention prefix reference.
+
+---
+
+
 ## See Also
 
 - **common-errors.md** — char-literal truncation listed as a known error pattern
 - **json.md** — safe patterns for building JSON strings in ABAP
 - **workflow-detailed.md** — where abaplint fits in the development workflow
+- **abaplint-local.md** — naming convention reference (prefixes for variables, parameters, field-symbols)

package/abap/guidelines/branch-workflow.md

@@ -21,6 +21,7 @@ edit src/zcl_auth_handler.clas.abap
 
 # 3. Check syntax (CLAS/INTF/PROG/DDLS only, if independent)
 abapgit-agent syntax --files src/zcl_auth_handler.clas.abap
+ls .abaplint.json 2>/dev/null && abapgit-agent lint   # abaplint (if configured)
 
 # 4. Commit
 git add src/zcl_auth_handler.clas.abap
@@ -72,10 +73,47 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
 abapgit-agent unit --files src/zcl_auth_handler.clas.testclasses.abap
 
 # 3. Create PR (squash merge enabled on GitHub/GitLab)
-# Go to GitHub and create PR from feature/user-authentication to main
-# Select "Squash and merge" option to combine all commits into one
+# See "Creating a PR" section below for transport handling
 ```
 
+#### Creating a PR
+
+When creating a PR with `gh pr create`:
+
+**Check `.abapgit-agent.json` for `transports.hook`.**
+
+```
+transports.hook present?
+├─ NO  → create PR normally, no transport line needed. STOP here.
+└─ YES → continue below
+```
+
+**If hook is configured — resolve which transport to include:**
+
+```bash
+abapgit-agent transport list --scope task --json
+```
+
+- **One result** → use it directly, no need to ask the user
+- **Multiple results** → show the list to the user and ask which one to use for this PR
+- **No results** → ask the user to provide a transport number manually, or confirm to skip
+
+**Append `transport: <number>` as the last line of the PR body:**
+
+```
+## Summary
+- Implemented user authentication handler
+
+## Changed Objects
+- ZCL_AUTH_HANDLER (CLAS)
+
+transport: DEVK900001
+```
+
+**Why:** The CI pipeline reads this line from the PR description and uses it for the
+Activate stage, overriding the automatic hook selection. This lets the user control
+which transport request receives the activated changes.
+
 #### Why Rebase Before Pull?
 
 ABAP is a **centralized system**. Multiple developers may modify the same files:
@@ -112,6 +150,7 @@ git checkout main && git pull origin main
 git checkout -b feature/user-authentication
 edit src/zcl_auth_handler.clas.abap
 abapgit-agent syntax --files src/zcl_auth_handler.clas.abap
+ls .abaplint.json 2>/dev/null && abapgit-agent lint   # abaplint (if configured)
 git add . && git commit -m "wip: add basic auth logic"
 git push origin feature/user-authentication
 git fetch origin main && git rebase origin/main
@@ -123,6 +162,8 @@ git fetch origin main && git rebase origin/main
 # If conflicts: resolve, git add, git rebase --continue
 git push origin feature/user-authentication --force-with-lease
 edit src/zcl_auth_handler.clas.abap
+abapgit-agent syntax --files src/zcl_auth_handler.clas.abap
+ls .abaplint.json 2>/dev/null && abapgit-agent lint   # abaplint (if configured)
 git add . && git commit -m "feat: complete auth logic"
 git push origin feature/user-authentication
 git fetch origin main && git rebase origin/main
@@ -133,5 +174,6 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
 abapgit-agent unit --files src/zcl_auth_handler.clas.testclasses.abap
 git fetch origin main && git rebase origin/main
 git push origin feature/user-authentication --force-with-lease
-# Create PR on GitHub/GitLab (squash 3 commits into 1)
+# Create PR: check transport hook, resolve transport, include in PR body
+# abapgit-agent transport list --scope task --json  → pick transport → append to PR body
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.13.7",
+  "version": "1.14.1",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",

package/src/commands/index.js

@@ -29,5 +29,6 @@ module.exports = {
   init:      require('./init'),
   pull:      require('./pull'),
   upgrade:   require('./upgrade'),
-  transport: require('./transport')
+  transport: require('./transport'),
+  lint:      require('./lint')
 };

package/src/commands/lint.js

@@ -0,0 +1,199 @@
+'use strict';
+
+/**
+ * lint command - Run abaplint on changed ABAP files
+ *
+ * Detects files changed relative to a base branch (or HEAD~1),
+ * creates a scoped abaplint config for just those files, and runs the check.
+ *
+ * Usage:
+ *   abapgit-agent lint
+ *   abapgit-agent lint --config .abaplint.json
+ *   abapgit-agent lint --base main
+ *   abapgit-agent lint --files src/foo.clas.abap,src/foo.clas.testclasses.abap
+ *   abapgit-agent lint --outformat checkstyle --outfile reports/abaplint-results.xml
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+module.exports = {
+  name: 'lint',
+  description: 'Run abaplint on changed ABAP files',
+  requiresAbapConfig: false,
+
+  execute(args) {
+    const configPath  = argValue(args, '--config')    || '.abaplint.json';
+    const baseBranch  = argValue(args, '--base');
+    const filesArg    = argValue(args, '--files');
+    const outformat   = argValue(args, '--outformat');
+    const outfile     = argValue(args, '--outfile');
+
+    // ── Resolve changed files ─────────────────────────────────────────────────
+    let abapFiles;
+    if (filesArg) {
+      abapFiles = filesArg.split(',').map(f => f.trim()).filter(f => f.endsWith('.abap'));
+    } else {
+      abapFiles = detectChangedAbapFiles(baseBranch);
+    }
+
+    if (abapFiles.length === 0) {
+      console.log('No changed .abap files found — nothing to lint.');
+      return;
+    }
+
+    if (!outfile) {
+      console.log(`\nLinting ${abapFiles.length} file(s):`);
+      abapFiles.forEach(f => console.log(`  ${f}`));
+      console.log('');
+    }
+
+    // ── Load and scope the abaplint config ────────────────────────────────────
+    if (!fs.existsSync(configPath)) {
+      console.error(`Error: abaplint config not found: ${configPath}`);
+      console.error('Run from the project root, or pass --config <path>.');
+      process.exit(1);
+    }
+
+    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+    // Scope to changed files + their direct dependencies (interfaces, superclasses)
+    // so abaplint can resolve cross-references without including the whole repo.
+    const abapDir = cfg.global.files.replace(/\/\*\*.*$/, '').replace(/^\//, '') || 'abap';
+    const depFiles = resolveDependencies(abapFiles, abapDir);
+    const allFiles = [...new Set([...abapFiles, ...depFiles])];
+    cfg.global.files = allFiles.map(f => `/${f}`);
+
+    const scopedConfig = '.abaplint-local.json';
+    fs.writeFileSync(scopedConfig, JSON.stringify(cfg, null, 2));
+
+    // ── Run abaplint ──────────────────────────────────────────────────────────
+    try {
+      const formatArgs = outformat ? `--outformat ${outformat}` : '';
+      const fileArgs   = outfile   ? `--outfile ${outfile}`     : '';
+      const result = spawnSync(
+        `npx @abaplint/cli@latest ${scopedConfig} ${formatArgs} ${fileArgs}`,
+        { stdio: 'inherit', shell: true }
+      );
+      if (result.status !== 0) {
+        process.exitCode = result.status;
+      }
+    } finally {
+      fs.unlinkSync(scopedConfig);
+    }
+  }
+};
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function argValue(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+
+/**
+ * Detect changed .abap files using git diff.
+ * - If on a PR branch (CHANGE_TARGET set, e.g. in CI): diffs against that target.
+ * - If --base is given: diffs against that branch.
+ * - Otherwise: diffs HEAD~1..HEAD (last commit).
+ */
+function detectChangedAbapFiles(baseBranch) {
+  const base = baseBranch
+    || (process.env.CHANGE_TARGET ? `origin/${process.env.CHANGE_TARGET}` : null);
+
+  let diffCmd;
+  if (base) {
+    diffCmd = `git diff --name-only ${base}...HEAD -- '*.abap'`;
+  } else {
+    // Fall back to uncommitted changes first, then last commit
+    const uncommitted = runGit('git diff --name-only HEAD -- *.abap').filter(Boolean);
+    if (uncommitted.length > 0) return filterAbapFiles(uncommitted);
+    diffCmd = `git diff --name-only HEAD~1 HEAD -- '*.abap'`;
+  }
+
+  return filterAbapFiles(runGit(diffCmd));
+}
+
+function runGit(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8' }).trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Resolve direct dependencies of the given ABAP files by scanning their source
+ * for interface/superclass/type references and mapping them to local files.
+ *
+ * Handles:
+ *   INTERFACES <name>.              → <name>.intf.abap + <name>.intf.xml
+ *   INHERITING FROM <name>          → <name>.clas.abap + <name>.clas.xml
+ *   TYPE REF TO <name>              → <name>.intf.abap or <name>.clas.abap (whichever exists)
+ *
+ * Only resolves one level deep — enough for abaplint to check the changed files.
+ * XML companion files are always included alongside their .abap counterpart
+ * so xml_consistency checks can run.
+ */
+function resolveDependencies(abapFiles, abapDir) {
+  const deps    = new Set();
+  const visited = new Set(abapFiles); // don't re-scan changed files as deps
+
+  // Patterns to extract referenced object names from ABAP source
+  const patterns = [
+    /^\s*INTERFACES\s+(\w+)\s*\./gim,
+    /INHERITING\s+FROM\s+(\w+)/gim,
+    /TYPE\s+REF\s+TO\s+(\w+)/gim,
+  ];
+
+  // BFS queue — seed with the changed files, then expand transitively
+  const queue = [...abapFiles];
+
+  while (queue.length > 0) {
+    const file = queue.shift();
+
+    let source;
+    try { source = fs.readFileSync(file, 'utf8'); } catch { continue; }
+
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(source)) !== null) {
+        const name = match[1].toLowerCase();
+        for (const suffix of [`${name}.intf`, `${name}.clas`]) {
+          const abapFile = path.join(abapDir, `${suffix}.abap`);
+          const xmlFile  = path.join(abapDir, `${suffix}.xml`);
+          if (fs.existsSync(abapFile)) {
+            deps.add(abapFile);
+            if (fs.existsSync(xmlFile)) deps.add(xmlFile);
+            // Recurse into this dep if not yet visited
+            if (!visited.has(abapFile)) {
+              visited.add(abapFile);
+              queue.push(abapFile);
+            }
+            break; // intf matched — don't also try clas
+          }
+        }
+      }
+    }
+
+    // Always include the XML companion of each scanned file
+    const xmlCompanion = file.replace(/\.abap$/, '.xml');
+    if (fs.existsSync(xmlCompanion)) deps.add(xmlCompanion);
+  }
+
+  return [...deps];
+}
+
+/**
+ * Keep only files that look like ABAP source files
+ * (name.type.abap or name.type.subtype.abap).
+ */
+function filterAbapFiles(files) {
+  return files.filter(f => {
+    const parts = path.basename(f).split('.');
+    return (parts.length === 3 || parts.length === 4) &&
+           parts[parts.length - 1].toLowerCase() === 'abap';
+  });
+}