Documentation API

{
  "status": "success",
  "analysis": {
    "program_id": "MAINPROG",
    "divisions": ["IDENTIFICATION", "ENVIRONMENT", "DATA", "PROCEDURE"],
    "complexity_score": 12,
    "lines_of_code": 487,
    "issues": [
      {
        "severity": "warning",
        "line": 125,
        "message": "Variable TEMP-VAR declared but not used",
        "suggestion": "Remove unused variables to improve code clarity"
      }
    ],
    "suggestions": [
      "Consider refactoring procedures longer than 50 lines",
      "Use EVALUATE instead of nested IF statements for better readability"
    ]
  },
  "tokens_used": 2340
}

pip install ubnbee-cobol

from ubnbee_cobol import Client

# Initialiser le client
client = Client(api_key="votre_cle_api")

# Analyser du code COBOL
with open("program.cbl", "r") as f:
    cobol_code = f.read()

result = client.analyze(
    code=cobol_code,
    options={
        "detect_issues": True,
        "complexity_analysis": True,
        "standards_check": "COBOL-2014"
    }
)

print(f"Complexité: {result.analysis.complexity_score}")
print(f"Lignes de code: {result.analysis.lines_of_code}")
print(f"Tokens utilisés: {result.tokens_used}")

# Générer la documentation
doc = client.generate_documentation(
    code=cobol_code,
    format="markdown",
    language="fr"
)

with open("documentation.md", "w") as f:
    f.write(doc.content)

npm install @ubnbee/cobol-sdk

const { CobolClient } = require('@ubnbee/cobol-sdk');
const fs = require('fs').promises;

// Initialiser le client
const client = new CobolClient({
  apiKey: 'votre_cle_api'
});

async function analyzeCobolProgram() {
  // Lire le fichier COBOL
  const cobolCode = await fs.readFile('program.cbl', 'utf8');

  // Analyser le code
  const result = await client.analyze({
    code: cobolCode,
    options: {
      detectIssues: true,
      complexityAnalysis: true,
      standardsCheck: 'COBOL-2014'
    }
  });

  console.log(`Complexité: ${result.analysis.complexityScore}`);
  console.log(`Lignes de code: ${result.analysis.linesOfCode}`);
  console.log(`Tokens utilisés: ${result.tokensUsed}`);

  // Générer la documentation
  const doc = await client.generateDocumentation({
    code: cobolCode,
    format: 'markdown',
    language: 'fr'
  });

  await fs.writeFile('documentation.md', doc.content);
}

analyzeCobolProgram().catch(console.error);

import os
from ubnbee_cobol import Client

client = Client(api_key="votre_cle_api")

# Parcourir tous les fichiers .cbl
results = []
for root, dirs, files in os.walk("/path/to/cobol/programs"):
    for file in files:
        if file.endswith(".cbl"):
            filepath = os.path.join(root, file)
            with open(filepath, "r") as f:
                code = f.read()

            result = client.analyze(code=code)
            results.append({
                "file": filepath,
                "complexity": result.analysis.complexity_score,
                "issues": len(result.analysis.issues),
                "loc": result.analysis.lines_of_code
            })

# Générer rapport
import pandas as pd
df = pd.DataFrame(results)
df.to_csv("audit_report.csv", index=False)

print(f"Programmes analysés: {len(results)}")
print(f"Complexité moyenne: {df['complexity'].mean():.2f}")
print(f"Total issues: {df['issues'].sum()}")

const { CobolClient } = require('@ubnbee/cobol-sdk');
const fs = require('fs').promises;
const path = require('path');

const client = new CobolClient({ apiKey: 'votre_cle_api' });

async function generateDocsForProject(srcDir, docsDir) {
  const files = await fs.readdir(srcDir);

  for (const file of files) {
    if (file.endsWith('.cbl')) {
      const filepath = path.join(srcDir, file);
      const code = await fs.readFile(filepath, 'utf8');

      const doc = await client.generateDocumentation({
        code,
        format: 'html',
        language: 'fr',
        includeDiagrams: true
      });

      const docPath = path.join(docsDir, `${file}.html`);
      await fs.writeFile(docPath, doc.content);

      console.log(`✓ Documentation générée: ${file}`);
    }
  }
}

generateDocsForProject('./src/cobol', './docs')
  .then(() => console.log('✅ Documentation complète générée'))
  .catch(console.error);

# .gitlab-ci.yml
stages:
  - test
  - quality

cobol_quality_check:
  stage: quality
  image: python:3.11
  before_script:
    - pip install ubnbee-cobol
  script:
    - python scripts/quality_check.py
  artifacts:
    reports:
      junit: quality_report.xml
    paths:
      - quality_report.xml
      - quality_report.html
  only:
    - merge_requests
    - main

# scripts/quality_check.py
import os
import sys
from ubnbee_cobol import Client

client = Client(api_key=os.getenv("UBNBEE_API_KEY"))

max_complexity = 15
max_issues_high = 0

failed = False
results = []

for file in os.listdir("src/"):
    if file.endswith(".cbl"):
        with open(f"src/{file}", "r") as f:
            code = f.read()

        result = client.analyze(code=code)

        high_issues = [i for i in result.analysis.issues if i.severity == "error"]

        if result.analysis.complexity_score > max_complexity:
            print(f"❌ {file}: Complexité trop élevée ({result.analysis.complexity_score})")
            failed = True

        if len(high_issues) > max_issues_high:
            print(f"❌ {file}: {len(high_issues)} erreurs critiques")
            failed = True

        results.append(result)

# Générer rapport JUnit XML
# ... (code de génération du rapport)

sys.exit(1 if failed else 0)