@bpmsoftwaresolutions/ai-engine-client 1.1.86 → 1.1.88

package/src/domains/repo.js

@@ -1,25 +1,128 @@
 export function createRepoDomain(client) {
   return {
-    listRepositories: (request) => client.listRepositories(request),
-    getRepository: (repositoryId) => client.getRepository(repositoryId),
-    listProjects: (request) => client.listProjects(request),
-    getProject: (projectId) => client.getProject(projectId),
-    listCodeFiles: (request) => client.listCodeFiles(request),
-    getCodeFile: (fileId) => client.getCodeFile(fileId),
-    getCodeFileContentWindow: (fileId, request) => client.getCodeFileContentWindow(fileId, request),
-    listCodeSymbolsByFile: (fileId, request) => client.listCodeSymbolsByFile(fileId, request),
-    getCodeSymbol: (symbolId, request) => client.getCodeSymbol(symbolId, request),
-    searchSymbols: (request) => client.searchSymbols(request),
-    getSymbolRelationships: (symbolId, request) => client.getSymbolRelationships(symbolId, request),
-    listCodeRelationships: (request) => client.listCodeRelationships(request),
-    listActionObservations: (request) => client.listActionObservations(request),
-    listCodebaseShapeFindings: (request) => client.listCodebaseShapeFindings(request),
-    listObjectFlowObservations: (request) => client.listObjectFlowObservations(request),
-    getChangeAnalysis: (request) => client.getChangeAnalysis(request),
-    listRefactorCandidates: (request) => client.listRefactorCandidates(request),
-    analyzeRefactorCandidate: (request) => client.analyzeRefactorCandidate(request),
-    getRepoRetrievalPacket: (retrievalPacketId) => client.getRepoRetrievalPacket(retrievalPacketId),
-    getRepoRetrievalPacketFragments: (retrievalPacketId) => client.getRepoRetrievalPacketFragments(retrievalPacketId),
-    evaluateProposalScope: (request) => client.evaluateProposalScope(request),
+    listRepositories({ limit } = {}) {
+      return client._request('/api/repo/repositories', {
+        query: { limit },
+      });
+    },
+
+    getRepository(repositoryId) {
+      return client._request(`/api/repo/repositories/${repositoryId}`);
+    },
+
+    listProjects({ repositoryId, repoKey, limit } = {}) {
+      return client._request('/api/repo/projects', {
+        query: { repository_id: repositoryId, repo_key: repoKey, limit },
+      });
+    },
+
+    getProject(projectId) {
+      return client._request(`/api/repo/projects/${projectId}`);
+    },
+
+    listCodeFiles({ repositoryId, projectId, language, pathPrefix, page = 1, pageSize = 50 } = {}) {
+      return client._request('/api/repo/files', {
+        query: {
+          repository_id: repositoryId,
+          project_id: projectId,
+          language,
+          path_prefix: pathPrefix,
+          page,
+          page_size: pageSize,
+        },
+      });
+    },
+
+    getCodeFile(fileId) {
+      return client._request(`/api/repo/files/${fileId}`);
+    },
+
+    getCodeFileContentWindow(fileId, { startLine = 1, endLine } = {}) {
+      return client._request(`/api/repo/files/${fileId}/content-window`, {
+        query: { start_line: startLine, end_line: endLine ?? startLine },
+      });
+    },
+
+    listCodeSymbolsByFile(fileId, { limit = 500 } = {}) {
+      return client._request(`/api/repo/files/${fileId}/symbols`, {
+        query: { limit },
+      });
+    },
+
+    getCodeSymbol(symbolId, { includeCode = false, maxLines = 120 } = {}) {
+      return client._request(`/api/repo/symbols/${symbolId}`, {
+        query: { include_code: includeCode, max_lines: maxLines },
+      });
+    },
+
+    searchSymbols({ query, projectScope, maxResults = 10 } = {}) {
+      return client._request('/api/repo/symbols/search', {
+        query: { query, project_scope: projectScope, max_results: maxResults },
+      });
+    },
+
+    getSymbolRelationships(symbolId, { relationshipType, depth = 1 } = {}) {
+      return client._request(`/api/repo/symbols/${symbolId}/relationships`, {
+        query: { relationship_type: relationshipType, depth },
+      });
+    },
+
+    listCodeRelationships({ repositoryId, projectId, relationshipType, limit = 100 } = {}) {
+      return client._request('/api/repo/relationships', {
+        query: { repository_id: repositoryId, project_id: projectId, relationship_type: relationshipType, limit },
+      });
+    },
+
+    listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit = 100 } = {}) {
+      return client._request('/api/repo/action-observations', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, symbol_id: symbolId, action_kind: actionKind, limit },
+      });
+    },
+
+    listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit = 100 } = {}) {
+      return client._request('/api/repo/shape/findings', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, severity, status, limit },
+      });
+    },
+
+    listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit = 100 } = {}) {
+      return client._request('/api/repo/object-flow-observations', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, object_kind: objectKind, boundary_kind: boundaryKind, limit },
+      });
+    },
+
+    getChangeAnalysis({ fileId, symbolId, limit = 25 } = {}) {
+      return client._request('/api/repo/change-analysis', {
+        query: { file_id: fileId, symbol_id: symbolId, limit },
+      });
+    },
+
+    listRefactorCandidates({ repositoryRoot, limit = 10 } = {}) {
+      return client._request('/api/repo/refactor-candidates', {
+        query: { repository_root: repositoryRoot, limit },
+      });
+    },
+
+    analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent } = {}) {
+      return client._request('/api/repo/refactor-candidate-analysis', {
+        method: 'POST',
+        body: { file_path: filePath, requested_by: requestedBy, packet_id: packetId, refactor_intent: refactorIntent },
+      });
+    },
+
+    getRepoRetrievalPacket(retrievalPacketId) {
+      return client._request(`/api/repo/retrieval/packets/${retrievalPacketId}`);
+    },
+
+    getRepoRetrievalPacketFragments(retrievalPacketId) {
+      return client._request(`/api/repo/retrieval/packets/${retrievalPacketId}/fragments`);
+    },
+
+    evaluateProposalScope({ filePath, projectId, changeType = 'refactor', requestedBy, refactorIntent } = {}) {
+      return client._request('/api/repo/proposal-scope-evaluation', {
+        method: 'POST',
+        body: { file_path: filePath, project_id: projectId, change_type: changeType, requested_by: requestedBy, refactor_intent: refactorIntent },
+      });
+    },
   };
 }

package/src/domains/reports.js

@@ -1,5 +1,20 @@
+import { cleanText, isPlainObject } from '../utils/text.js';
+
 export function createReportsDomain(client) {
   return {
-    run: (request) => client.runReportDefinition(request),
+    run({ reportKey, definition = {}, requestedBy } = {}) {
+      const normalizedReportKey = cleanText(reportKey);
+      if (!normalizedReportKey) {
+        throw new Error('reportKey is required.');
+      }
+      return client._request('/api/gateway/reports/run', {
+        method: 'POST',
+        body: {
+          report_key: normalizedReportKey,
+          definition: isPlainObject(definition) ? definition : {},
+          requested_by: cleanText(requestedBy),
+        },
+      });
+    },
   };
 }

package/src/domains/retrieval-management.js

@@ -1,14 +1,23 @@
 export function createRetrievalManagementDomain(client) {
   return {
-    getRetrievalStatus: () => client.getRetrievalStatus(),
-    getRetrievalProfileMetrics: () => client.getRetrievalProfileMetrics(),
-    getRetrievalFeedbackMetrics: () => client.getRetrievalFeedbackMetrics(),
-    getRetrievalQuery: (retrievalQueryId) => client.getRetrievalQuery(retrievalQueryId),
-    getRetrievalPacket: (retrievalPacketId) => client.getRetrievalPacket(retrievalPacketId),
-    generateRetrievalCandidates: (body) => client.generateRetrievalCandidates(body),
-    selectRetrievalPacket: (body) => client.selectRetrievalPacket(body),
-    recordRetrievalFeedback: (body) => client.recordRetrievalFeedback(body),
-    deriveRetrievalOptimizationCandidates: (body) => client.deriveRetrievalOptimizationCandidates(body),
-    validatePromptAssembly: (body) => client.validatePromptAssembly(body),
+    getRetrievalStatus: () => client._request('/api/operator/retrieval/status'),
+
+    getRetrievalProfileMetrics: () => client._request('/api/operator/retrieval/profiles/metrics'),
+
+    getRetrievalFeedbackMetrics: () => client._request('/api/operator/retrieval/feedback-metrics'),
+
+    getRetrievalQuery: (retrievalQueryId) => client._request(`/api/operator/retrieval/queries/${retrievalQueryId}`),
+
+    getRetrievalPacket: (retrievalPacketId) => client._request(`/api/operator/retrieval/packets/${retrievalPacketId}`),
+
+    generateRetrievalCandidates: (body) => client._request('/api/operator/retrieval/generate-candidates', { method: 'POST', body }),
+
+    selectRetrievalPacket: (body) => client._request('/api/operator/retrieval/select-packet', { method: 'POST', body }),
+
+    recordRetrievalFeedback: (body) => client._request('/api/operator/retrieval/feedback', { method: 'POST', body }),
+
+    deriveRetrievalOptimizationCandidates: (body) => client._request('/api/operator/retrieval/optimization-candidates', { method: 'POST', body }),
+
+    validatePromptAssembly: (body) => client._request('/api/operator/retrieval/validate-prompt-assembly', { method: 'POST', body }),
   };
 }

package/src/domains/retrieval-wrapper.js

@@ -1,7 +1,43 @@
 export function createRetrievalWrapperDomain(client) {
   return {
-    getCommandCard: (request) => client.getCommandCard(request),
-    getSymbolDefinition: (request) => client.getSymbolDefinition(request),
-    getRelatedCode: (request) => client.getRelatedCode(request),
+    getCommandCard({ commandKey, alias, intentText, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/command-card', {
+        query: { command_key: commandKey, alias, intent_text: intentText, requested_by: requestedBy },
+      });
+    },
+
+    resolveOperatingProcedure({ procedureKey, intentText, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/operating-procedure', {
+        query: { procedure_key: procedureKey, intent_text: intentText, requested_by: requestedBy },
+      });
+    },
+
+    getSymbolDefinition({ symbolKey, qualifiedName, symbolName, projectScope, includeCode = true, maxLines = 120, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/symbol-definition', {
+        query: {
+          symbol_key: symbolKey,
+          qualified_name: qualifiedName,
+          symbol_name: symbolName,
+          project_scope: projectScope,
+          include_code: includeCode,
+          max_lines: maxLines,
+          requested_by: requestedBy,
+        },
+      });
+    },
+
+    getRelatedCode({ symbolKey, qualifiedName, relationshipType, depth = 1, includeCode = false, maxLines = 80, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/related-code', {
+        query: {
+          symbol_key: symbolKey,
+          qualified_name: qualifiedName,
+          relationship_type: relationshipType,
+          depth,
+          include_code: includeCode,
+          max_lines: maxLines,
+          requested_by: requestedBy,
+        },
+      });
+    },
   };
 }

package/src/domains/roadmap-reports.js

@@ -0,0 +1,6 @@
+export function createRoadmapReportsDomain(client) {
+  return {
+    getProjectImplementationRoadmapReport: (projectId) => client._request(`/api/operator/projects/${projectId}/implementation-roadmap/report`),
+    downloadProjectImplementationRoadmapReportMarkdown: (projectId) => client._requestText(`/api/operator/projects/${projectId}/markdown-reports/implementation_roadmap/download`),
+  };
+}