Skip to content

FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.

code fixes

tilakpatel22cb8d28839398
diff --git a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/PortfolioOptimizationView.tsx b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/PortfolioOptimizationView.tsx
index 6c5ee76e1..9b3873e9c 100644
--- a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/PortfolioOptimizationView.tsx
+++ b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/PortfolioOptimizationView.tsx
@@ -91,6 +91,9 @@ interface OptimizationResults {
expected_annual_return: number;
annual_volatility: number;
sharpe_ratio: number;
+ sortino_ratio?: number;
+ calmar_ratio?: number;
+ max_drawdown?: number;
};
discrete_allocation?: {
allocation: Record<string, number>;
@@ -1370,10 +1373,10 @@ const PortfolioOptimizationView: React.FC<PortfolioOptimizationViewProps> = ({ p
{/* Prepare chart data */}
{(() => {
- const chartData = results.efficient_frontier.returns.map((ret: number, idx: number) => ({
- volatility: parseFloat((results.efficient_frontier.volatility[idx] * 100).toFixed(2)),
+ const chartData = results.efficient_frontier!.returns.map((ret: number, idx: number) => ({
+ volatility: parseFloat((results.efficient_frontier!.volatility[idx] * 100).toFixed(2)),
returns: parseFloat((ret * 100).toFixed(2)),
- sharpe: parseFloat(results.efficient_frontier.sharpe_ratios?.[idx]?.toFixed(3) || '0'),
+ sharpe: parseFloat(results.efficient_frontier!.sharpe_ratios?.[idx]?.toFixed(3) || '0'),
}));
// Custom dot component for better visualization
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentMediatorNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentMediatorNode.ts
index 767827446..d6484f790 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentMediatorNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentMediatorNode.ts
@@ -153,7 +153,7 @@ export class AgentMediatorNode implements INodeType {
const field = this.getNodeParameter('responsesField', 0) as string;
const firstItem = inputData[0]?.json;
if (firstItem && Array.isArray(firstItem[field])) {
- responses = firstItem[field];
+ responses = firstItem[field] as Array<{ agentId: string; agentName?: string; response: string }>;
}
originalQuery = originalQuery || (firstItem?.query as string) || '';
break;
@@ -175,7 +175,7 @@ export class AgentMediatorNode implements INodeType {
// Try to find responses in common formats
if (firstItem?.responses && Array.isArray(firstItem.responses)) {
- responses = firstItem.responses;
+ responses = firstItem.responses as Array<{ agentId: string; agentName?: string; response: string }>;
} else if (firstItem?.synthesis) {
// Already synthesized, just pass through
return [[{ json: firstItem }]];
@@ -205,59 +205,33 @@ export class AgentMediatorNode implements INodeType {
const focusAreas = focusAreasStr ? focusAreasStr.split(',').map(s => s.trim()) : [];
- const bridge = new AgentBridge();
-
try {
- const result = await bridge.mediateResults(
- responses.filter(r => r.response),
- {
- llmProvider,
- model,
- mode: mediationMode,
- maxLength,
- focusAreas,
- includeAttribution,
- generateRecommendations,
- originalQuery,
- }
- );
+ // Convert responses to AgentExecutionResult format
+ const agentResults: any[] = responses.filter(r => r.response).map(r => ({
+ success: true,
+ agentId: r.agentId,
+ agentName: r.agentName,
+ data: { response: r.response },
+ }));
+
+ // Build mediation prompt
+ const mediationPrompt = `Mode: ${mediationMode}. Original query: ${originalQuery}. ${
+ focusAreas.length > 0 ? `Focus on: ${focusAreas.join(', ')}.` : ''
+ }`;
- const output: Record<string, unknown> = {
+ const result = await AgentBridge.mediateResults(agentResults, mediationPrompt);
+
+ const output: Record<string, any> = {
success: true,
mediationMode,
agentCount: responses.length,
originalQuery,
- synthesis: result.synthesis,
+ synthesis: result,
timestamp: new Date().toISOString(),
};
- if (mediationMode === 'debate' || mediationMode === 'compare') {
- output.viewpoints = result.viewpoints || [];
- output.differences = result.differences || [];
- }
-
- if (mediationMode === 'consensus') {
- output.agreements = result.agreements || [];
- output.disagreements = result.disagreements || [];
- output.consensusLevel = result.consensusLevel;
- }
-
- if (mediationMode === 'rank') {
- output.ranking = result.ranking || [];
- }
-
- if (mediationMode === 'actions' || generateRecommendations) {
- output.recommendations = result.recommendations || [];
- output.actionItems = result.actionItems || [];
- }
-
- if (includeAttribution) {
- output.attributions = result.attributions || [];
- }
-
- if (focusAreas.length > 0) {
- output.focusAreaAnalysis = result.focusAreaAnalysis || {};
- }
+ // Simple mediation result - just include the synthesis
+ output.analysis = result;
return [[{ json: output }]];
} catch (error) {
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentNode.ts
index 9fd932bfd..969135c03 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/AgentNode.ts
@@ -186,7 +186,7 @@ export class AgentNode implements INodeType {
}
// Parse context
- let context: Record<string, unknown> = {};
+ let context: Record<string, any> = {};
try {
const contextStr = this.getNodeParameter('context', 0) as string;
context = JSON.parse(contextStr);
@@ -198,21 +198,23 @@ export class AgentNode implements INodeType {
const agentDef = AGENT_DEFINITIONS.find(a => a.id === agentId);
const agentName = agentDef?.name || agentId;
- const bridge = new AgentBridge();
-
try {
- const result = await bridge.executeAgent(agentId || category, {
- query,
- context,
- llmProvider,
- model,
- maxTokens,
- temperature,
- timeout: timeout * 1000,
+ const result = await AgentBridge.executeAgent({
+ agentId: agentId || category,
+ category: category as any,
+ parameters: {
+ query,
+ context,
+ maxTokens,
+ temperature,
+ timeout: timeout * 1000,
+ },
+ llmProvider: llmProvider as any,
+ llmModel: model,
});
// Format output based on preference
- let formattedOutput: Record<string, unknown> = {
+ let formattedOutput: Record<string, any> = {
success: true,
agentId: agentId || category,
agentName,
@@ -220,22 +222,25 @@ export class AgentNode implements INodeType {
query,
};
+ const responseData = result.data || {};
+ const responseText = responseData.response || responseData.analysis || JSON.stringify(responseData);
+
switch (outputFormat) {
case 'summary':
- formattedOutput.summary = result.summary || result.response?.substring(0, 500);
+ formattedOutput.summary = responseData.summary || responseText?.substring(0, 500);
break;
case 'keyPoints':
- formattedOutput.keyPoints = result.keyPoints || this.extractKeyPoints(result.response);
+ formattedOutput.keyPoints = responseData.keyPoints || AgentNode.extractKeyPointsStatic(responseText);
break;
case 'json':
- formattedOutput.structured = result.structured || this.structureResponse(result.response);
+ formattedOutput.structured = responseData.structured || AgentNode.structureResponseStatic(responseText);
break;
case 'full':
default:
- formattedOutput.response = result.response;
- formattedOutput.analysis = result.analysis;
- if (includeSources && result.sources) {
- formattedOutput.sources = result.sources;
+ formattedOutput.response = responseText;
+ formattedOutput.analysis = responseData.analysis;
+ if (includeSources && responseData.sources) {
+ formattedOutput.sources = responseData.sources;
}
}
@@ -260,7 +265,7 @@ export class AgentNode implements INodeType {
}
}
- private extractKeyPoints(response: string): string[] {
+ private static extractKeyPointsStatic(response: string): string[] {
// Simple key point extraction
if (!response) return [];
@@ -278,7 +283,7 @@ export class AgentNode implements INodeType {
return keyPoints.length > 0 ? keyPoints : lines.slice(0, 5);
}
- private structureResponse(response: string): Record<string, unknown> {
+ private static structureResponseStatic(response: string): Record<string, unknown> {
// Try to extract structured data from response
return {
raw: response,
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/GeopoliticsAgentNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/GeopoliticsAgentNode.ts
index f81e0bc12..36ed536bc 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/GeopoliticsAgentNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/GeopoliticsAgentNode.ts
@@ -177,7 +177,7 @@ export class GeopoliticsAgentNode implements INodeType {
],
};
- private readonly frameworkDescriptions: Record<string, string> = {
+ private static readonly frameworkDescriptions: Record<string, string> = {
grand_chessboard: 'Brzezinski\'s analysis of Eurasia as the center of world power and American grand strategy',
prisoners_geography: 'How physical geography shapes nations\' destinies and limits their options',
world_order: 'Kissinger\'s analysis of different concepts of international order throughout history',
@@ -214,9 +214,9 @@ export class GeopoliticsAgentNode implements INodeType {
}]];
}
- const context: Record<string, unknown> = {
+ const context: Record<string, any> = {
framework,
- frameworkDescription: this.frameworkDescriptions[framework.split('_')[0]] || '',
+ frameworkDescription: GeopoliticsAgentNode.frameworkDescriptions[framework.split('_')[0]] || '',
analysisFocus,
timeHorizon,
includeMarketImpact,
@@ -253,47 +253,50 @@ export class GeopoliticsAgentNode implements INodeType {
query += ` Time horizon: ${timeHorizon}.`;
- const bridge = new AgentBridge();
-
try {
- const result = await bridge.executeAgent(`geopolitics_${framework}`, {
- query,
- context,
- llmProvider,
- model,
+ const result = await AgentBridge.executeAgent({
+ agentId: `geopolitics_${framework}`,
+ category: 'geopolitics',
+ parameters: {
+ query,
+ ...context,
+ },
+ llmProvider: llmProvider as any,
+ llmModel: model,
});
- const output: Record<string, unknown> = {
+ const responseData = result.data || {};
+ const output: Record<string, any> = {
success: true,
framework,
frameworkDescription: context.frameworkDescription,
topic,
analysisFocus,
timeHorizon,
- analysis: result.response,
- keyInsights: result.keyInsights || [],
+ analysis: responseData.response || responseData.analysis || '',
+ keyInsights: responseData.keyInsights || [],
timestamp: new Date().toISOString(),
executionId: this.getExecutionId(),
};
// Add focus-specific outputs
- if (analysisFocus === 'risk' && result.risks) {
- output.risks = result.risks;
- output.riskLevel = result.riskLevel;
+ if (analysisFocus === 'risk' && responseData.risks) {
+ output.risks = responseData.risks;
+ output.riskLevel = responseData.riskLevel;
}
- if (analysisFocus === 'scenarios' && result.scenarios) {
- output.scenarios = result.scenarios;
+ if (analysisFocus === 'scenarios' && responseData.scenarios) {
+ output.scenarios = responseData.scenarios;
}
- if (includeMarketImpact && result.marketImpact) {
- output.marketImpact = result.marketImpact;
- output.tradingIdeas = result.tradingIdeas || [];
- output.hedgingStrategies = result.hedgingStrategies || [];
+ if (includeMarketImpact && responseData.marketImpact) {
+ output.marketImpact = responseData.marketImpact;
+ output.tradingIdeas = responseData.tradingIdeas || [];
+ output.hedgingStrategies = responseData.hedgingStrategies || [];
}
- if (result.historicalParallels) {
- output.historicalParallels = result.historicalParallels;
+ if (responseData.historicalParallels) {
+ output.historicalParallels = responseData.historicalParallels;
}
return [[{ json: output }]];
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/HedgeFundAgentNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/HedgeFundAgentNode.ts
index fe9ce0b8e..40657ce6e 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/HedgeFundAgentNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/HedgeFundAgentNode.ts
@@ -179,7 +179,7 @@ export class HedgeFundAgentNode implements INodeType {
],
};
- private readonly strategyDescriptions: Record<string, { description: string; characteristics: string[] }> = {
+ private static readonly strategyDescriptions: Record<string, { description: string; characteristics: string[] }> = {
long_short_equity: {
description: 'Combines long positions in undervalued stocks with short positions in overvalued stocks',
characteristics: ['Stock selection', 'Sector analysis', 'Relative value', 'Factor exposure'],
@@ -234,10 +234,10 @@ export class HedgeFundAgentNode implements INodeType {
const model = this.getNodeParameter('model', 0) as string;
const inputData = this.getInputData();
- const strategyInfo = this.strategyDescriptions[strategy];
+ const strategyInfo = HedgeFundAgentNode.strategyDescriptions[strategy];
// Build context based on analysis mode
- const context: Record<string, unknown> = {
+ const context: Record<string, any> = {
strategy,
strategyInfo,
focus,
@@ -291,17 +291,20 @@ export class HedgeFundAgentNode implements INodeType {
context.eventType = this.getNodeParameter('eventType', 0) as string;
}
- const bridge = new AgentBridge();
-
try {
- const result = await bridge.executeAgent(`hedgefund_${strategy}`, {
- query,
- context,
- llmProvider,
- model,
+ const result = await AgentBridge.executeAgent({
+ agentId: `hedgefund_${strategy}`,
+ category: 'hedgeFund',
+ parameters: {
+ query,
+ ...context,
+ },
+ llmProvider: llmProvider as any,
+ llmModel: model,
});
- const output: Record<string, unknown> = {
+ const responseData = result.data || {};
+ const output: Record<string, any> = {
success: true,
strategy,
strategyDescription: strategyInfo?.description,
@@ -311,26 +314,26 @@ export class HedgeFundAgentNode implements INodeType {
riskTolerance,
timeHorizon,
capitalAllocation,
- analysis: result.response,
+ analysis: responseData.response || responseData.analysis || '',
timestamp: new Date().toISOString(),
executionId: this.getExecutionId(),
};
// Parse structured output if available
- if (result.opportunities) {
- output.opportunities = result.opportunities;
+ if (responseData.opportunities) {
+ output.opportunities = responseData.opportunities;
}
- if (result.positions) {
- output.recommendedPositions = result.positions;
+ if (responseData.positions) {
+ output.recommendedPositions = responseData.positions;
}
- if (result.hedges && includeHedges) {
- output.hedges = result.hedges;
+ if (responseData.hedges && includeHedges) {
+ output.hedges = responseData.hedges;
}
- if (result.riskMetrics) {
- output.riskMetrics = result.riskMetrics;
+ if (responseData.riskMetrics) {
+ output.riskMetrics = responseData.riskMetrics;
}
- if (result.marketRegime) {
- output.marketRegime = result.marketRegime;
+ if (responseData.marketRegime) {
+ output.marketRegime = responseData.marketRegime;
}
return [[{ json: output }]];
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/InvestorAgentNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/InvestorAgentNode.ts
index a0facff32..ba5d56706 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/InvestorAgentNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/InvestorAgentNode.ts
@@ -173,7 +173,7 @@ export class InvestorAgentNode implements INodeType {
],
};
- private readonly investorStyles: Record<string, { principles: string[]; focusAreas: string[] }> = {
+ private static readonly investorStyles: Record<string, { principles: string[]; focusAreas: string[] }> = {
warren_buffett: {
principles: ['Economic moats', 'Long-term holding', 'Circle of competence', 'Margin of safety', 'Quality management'],
focusAreas: ['Return on equity', 'Debt levels', 'Consistent earnings', 'Brand value', 'Pricing power'],
@@ -217,7 +217,7 @@ export class InvestorAgentNode implements INodeType {
// Get input data based on analysis type
let analysisTarget: string = '';
- let additionalData: Record<string, unknown> = {};
+ let additionalData: Record<string, any> = {};
const inputData = this.getInputData();
@@ -280,24 +280,21 @@ export class InvestorAgentNode implements INodeType {
}
// Get investor style
- const investorStyle = this.investorStyles[investor] || { principles: [], focusAreas: [] };
-
- const bridge = new AgentBridge();
+ const investorStyle = InvestorAgentNode.investorStyles[investor] || { principles: [], focusAreas: [] };
try {
- const result = await bridge.executeAgent(`investor_${investor}`, {
- query: this.buildQuery(analysisType, analysisTarget, context),
- context: {
- investor,
- investorStyle,
- analysisType,
- analysisTarget,
+ const result = await AgentBridge.executeAgent({
+ agentId: `investor_${investor}`,
+ category: 'investor',
+ parameters: {
+ query: InvestorAgentNode.buildQueryStatic(analysisType, analysisTarget, context),
...additionalData,
},
- llmProvider,
- model,
+ llmProvider: llmProvider as any,
+ llmModel: model,
});
+ const responseData = result.data || {};
return [[{
json: {
success: true,
@@ -305,11 +302,11 @@ export class InvestorAgentNode implements INodeType {
investorStyle,
analysisType,
analysisTarget,
- analysis: result.response,
- keyInsights: result.keyInsights || [],
- recommendation: result.recommendation,
- riskFactors: result.riskFactors || [],
- confidence: result.confidence,
+ analysis: responseData.response || responseData.analysis || '',
+ keyInsights: responseData.keyInsights || [],
+ recommendation: responseData.recommendation,
+ riskFactors: responseData.riskFactors || [],
+ confidence: responseData.confidence,
principles: investorStyle.principles,
timestamp: new Date().toISOString(),
executionId: this.getExecutionId(),
@@ -329,7 +326,7 @@ export class InvestorAgentNode implements INodeType {
}
}
- private buildQuery(analysisType: string, target: string, context: string): string {
+ private static buildQueryStatic(analysisType: string, target: string, context: string): string {
const queries: Record<string, string> = {
stockAnalysis: `Analyze ${target} as an investment opportunity. ${context}`,
portfolioReview: `Review this portfolio and provide recommendations. ${context}`,
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/MultiAgentNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/MultiAgentNode.ts
index 05236a5f9..f21df6b64 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/MultiAgentNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/agents/MultiAgentNode.ts
@@ -224,7 +224,7 @@ export class MultiAgentNode implements INodeType {
switch (agentSelection) {
case 'preset': {
const preset = this.getNodeParameter('presetGroup', 0) as string;
- agentIds = this.getPresetAgents(preset);
+ agentIds = MultiAgentNode.getPresetAgentsStatic(preset);
break;
}
case 'category': {
@@ -250,24 +250,35 @@ export class MultiAgentNode implements INodeType {
}]];
}
- const bridge = new AgentBridge();
const startTime = Date.now();
try {
- // Execute agents
- const results = await bridge.executeMultipleAgents(agentIds, {
- query,
- llmProvider,
- model,
- timeout: timeout * 1000,
+ // Build requests for each agent
+ const agentRequests = agentIds.map(agentId => {
+ const agentDef = AGENT_DEFINITIONS.find(a => a.id === agentId);
+ return {
+ agentId,
+ category: (agentDef?.category as any) || 'geopolitics',
+ parameters: {
+ query,
+ },
+ llmProvider: llmProvider as any,
+ llmModel: model,
+ };
+ });
+
+ // Execute agents using MultiAgentRequest interface
+ const multiAgentResult = await AgentBridge.executeMultipleAgents({
+ agents: agentRequests,
parallel: executionMode === 'parallel',
- continueOnError,
+ llmProvider: llmProvider as any,
});
const executionTime = Date.now() - startTime;
+ const results = multiAgentResult.agentResults;
// Process results based on aggregation mode
- const output: Record<string, unknown> = {
+ const output: Record<string, any> = {
success: true,
query,
agentCount: agentIds.length,
@@ -284,25 +295,21 @@ export class MultiAgentNode implements INodeType {
agentId: r.agentId,
agentName: AGENT_DEFINITIONS.find(a => a.id === r.agentId)?.name || r.agentId,
success: r.success,
- response: r.response,
+ response: r.data?.response || r.data?.analysis || JSON.stringify(r.data),
error: r.error,
}));
break;
case 'synthesize': {
- const synthesis = await bridge.mediateResults(
- results.filter(r => r.success).map(r => ({
- agentId: r.agentId,
- response: r.response,
- })),
- { llmProvider, model }
+ const synthesis = await AgentBridge.mediateResults(
+ results.filter(r => r.success),
);
output.synthesis = synthesis;
break;
}
case 'consensus': {
- output.consensus = this.findConsensus(results);
+ output.consensus = MultiAgentNode.findConsensusStatic(results);
break;
}
@@ -311,19 +318,15 @@ export class MultiAgentNode implements INodeType {
agentId: r.agentId,
agentName: AGENT_DEFINITIONS.find(a => a.id === r.agentId)?.name || r.agentId,
success: r.success,
- response: r.response,
+ response: r.data?.response || r.data?.analysis || JSON.stringify(r.data),
error: r.error,
}));
- const synthesis = await bridge.mediateResults(
- results.filter(r => r.success).map(r => ({
- agentId: r.agentId,
- response: r.response,
- })),
- { llmProvider, model }
+ const synthesis = await AgentBridge.mediateResults(
+ results.filter(r => r.success),
);
output.synthesis = synthesis;
- output.consensus = this.findConsensus(results);
+ output.consensus = MultiAgentNode.findConsensusStatic(results);
break;
}
}
@@ -342,7 +345,7 @@ export class MultiAgentNode implements INodeType {
}
}
- private getPresetAgents(preset: string): string[] {
+ private static getPresetAgentsStatic(preset: string): string[] {
const presets: Record<string, string[]> = {
geopolitics_full: AGENT_DEFINITIONS.filter(a => a.category === 'geopolitics').map(a => a.id),
geopolitics_core: ['grand_chessboard', 'world_order', 'prisoners_geography', 'rise_fall_powers', 'clash_civilizations'],
@@ -356,7 +359,7 @@ export class MultiAgentNode implements INodeType {
return presets[preset] || [];
}
- private findConsensus(results: any[]): Record<string, unknown> {
+ private static findConsensusStatic(results: any[]): Record<string, any> {
const successfulResults = results.filter(r => r.success);
if (successfulResults.length < 2) {
@@ -369,7 +372,8 @@ export class MultiAgentNode implements INodeType {
// Simple word frequency analysis for finding common themes
const allWords: Record<string, number> = {};
for (const result of successfulResults) {
- const words = (result.response || '').toLowerCase().split(/\s+/);
+ const responseText = result.data?.response || result.data?.analysis || JSON.stringify(result.data) || '';
+ const words = (responseText as string).toLowerCase().split(/\s+/);
const uniqueWords = new Set(words);
for (const word of uniqueWords) {
if (word.length > 5) { // Only meaningful words
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/base/BaseFinanceNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/base/BaseFinanceNode.ts
index e15f6ddae..1d75a7bd9 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/base/BaseFinanceNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/base/BaseFinanceNode.ts
@@ -400,14 +400,17 @@ export function createTradingNodeDescription(
// EXPORTS
// ================================
-export {
+export type {
INodeType,
INodeTypeDescription,
IExecuteFunctions,
NodeOutput,
INodeExecutionData,
IDataObject,
+ INodeProperties,
+};
+
+export {
NodeConnectionType,
NodePropertyType,
- INodeProperties,
};
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetFundamentalsNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetFundamentalsNode.ts
index ce943103f..c9e201aba 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetFundamentalsNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetFundamentalsNode.ts
@@ -151,13 +151,12 @@ export class GetFundamentalsNode implements INodeType {
}]];
}
- const bridge = new MarketDataBridge();
+
try {
- const fundamentals = await bridge.getFundamentals(symbol, dataType, provider);
+ const fundamentals = await MarketDataBridge.getFundamentals(symbol, provider as any);
- const result: Record<string, unknown> = {
- symbol,
+ const result: Record<string, any> = {
dataType,
provider,
...fundamentals,
@@ -166,7 +165,7 @@ export class GetFundamentalsNode implements INodeType {
// Add industry comparison if requested
if (includeIndustry && fundamentals.industry) {
- result.industryComparison = await this.getIndustryComparison(symbol, fundamentals);
+ result.industryComparison = await GetFundamentalsNode.getIndustryComparison(symbol, fundamentals);
}
return [[{ json: result }]];
@@ -182,7 +181,7 @@ export class GetFundamentalsNode implements INodeType {
}
}
- private async getIndustryComparison(symbol: string, data: any): Promise<Record<string, unknown>> {
+ private static async getIndustryComparison(symbol: string, data: any): Promise<Record<string, any>> {
// Mock industry comparison - would call actual API in production
return {
industry: data.industry || 'Technology',
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetHistoricalDataNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetHistoricalDataNode.ts
index 2cec8eb2c..56329c116 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetHistoricalDataNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetHistoricalDataNode.ts
@@ -228,19 +228,19 @@ export class GetHistoricalDataNode implements INodeType {
}
// Fetch historical data using the bridge
- const bridge = new MarketDataBridge();
+
try {
- const data = await bridge.getHistoricalData(symbol, {
+ const data = await MarketDataBridge.getHistoricalData({
+ symbol,
interval,
period,
startDate,
endDate,
- limit: numBars,
provider,
});
- const candles = data.candles || [];
+ const candles = data || [];
// Format output based on preference
switch (outputFormat) {
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetMarketDepthNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetMarketDepthNode.ts
index edb99b148..2a6615866 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetMarketDepthNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetMarketDepthNode.ts
@@ -125,12 +125,12 @@ export class GetMarketDepthNode implements INodeType {
}]];
}
- const bridge = new MarketDataBridge();
+
try {
- const depth = await bridge.getMarketDepth(symbol, parseInt(levels) || 10, provider);
+ const depth = await MarketDataBridge.getMarketDepth(symbol, provider as any, parseInt(levels) || 10);
- const result: Record<string, unknown> = {
+ const result: Record<string, any> = {
symbol,
levels: parseInt(levels) || 10,
provider,
@@ -141,10 +141,10 @@ export class GetMarketDepthNode implements INodeType {
};
if (includeStats && depth.bids && depth.asks) {
- const totalBidVolume = depth.bids.reduce((sum: number, [, qty]: [number, number]) => sum + qty, 0);
- const totalAskVolume = depth.asks.reduce((sum: number, [, qty]: [number, number]) => sum + qty, 0);
- const bestBid = depth.bids[0]?.[0] || 0;
- const bestAsk = depth.asks[0]?.[0] || 0;
+ const totalBidVolume = depth.bids.reduce((sum: number, item: { price: number; quantity: number }) => sum + item.quantity, 0);
+ const totalAskVolume = depth.asks.reduce((sum: number, item: { price: number; quantity: number }) => sum + item.quantity, 0);
+ const bestBid = depth.bids[0]?.price || 0;
+ const bestAsk = depth.asks[0]?.price || 0;
const spread = bestAsk - bestBid;
const spreadPercent = bestBid > 0 ? (spread / bestBid) * 100 : 0;
const midPrice = (bestBid + bestAsk) / 2;
@@ -163,8 +163,8 @@ export class GetMarketDepthNode implements INodeType {
}
if (includeImbalance && depth.bids && depth.asks) {
- const bidVolume = depth.bids.slice(0, 5).reduce((sum: number, [, qty]: [number, number]) => sum + qty, 0);
- const askVolume = depth.asks.slice(0, 5).reduce((sum: number, [, qty]: [number, number]) => sum + qty, 0);
+ const bidVolume = depth.bids.slice(0, 5).reduce((sum: number, item: { price: number; quantity: number }) => sum + item.quantity, 0);
+ const askVolume = depth.asks.slice(0, 5).reduce((sum: number, item: { price: number; quantity: number }) => sum + item.quantity, 0);
const totalVolume = bidVolume + askVolume;
const imbalance = totalVolume > 0 ? (bidVolume - askVolume) / totalVolume : 0;
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetQuoteNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetQuoteNode.ts
index f113d613c..7b1c0b3f2 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetQuoteNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetQuoteNode.ts
@@ -11,7 +11,7 @@ import {
NodeConnectionType,
NodePropertyType,
} from '../../types';
-import { MarketDataBridge } from '../../adapters/MarketDataBridge';
+import { MarketDataBridge, DataProvider } from '../../adapters/MarketDataBridge';
export class GetQuoteNode implements INodeType {
description: INodeTypeDescription = {
@@ -136,12 +136,10 @@ export class GetQuoteNode implements INodeType {
],
};
- private bridge = new MarketDataBridge();
-
async execute(this: IExecuteFunctions): Promise<NodeOutput> {
const useInputSymbols = this.getNodeParameter('useInputSymbols', 0) as boolean;
const assetType = this.getNodeParameter('assetType', 0) as string;
- const provider = this.getNodeParameter('provider', 0) as string;
+ const provider = this.getNodeParameter('provider', 0) as DataProvider;
const includeDetails = this.getNodeParameter('includeDetails', 0) as boolean;
let symbols: string[] = [];
@@ -175,17 +173,16 @@ export class GetQuoteNode implements INodeType {
}
// Fetch quotes using the bridge
- const bridge = new MarketDataBridge();
- const results: Array<{ json: Record<string, unknown> }> = [];
+
+ const results: Array<{ json: Record<string, any> }> = [];
for (const symbol of symbols) {
try {
- const quote = await bridge.getQuote(symbol, provider);
+ const quote = await MarketDataBridge.getQuote(symbol, provider);
if (includeDetails) {
results.push({
json: {
- symbol,
...quote,
assetType,
provider,
@@ -196,7 +193,7 @@ export class GetQuoteNode implements INodeType {
// Minimal quote data
results.push({
json: {
- symbol,
+ symbol: quote.symbol,
price: quote.price,
change: quote.change,
changePercent: quote.changePercent,
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetTickerStatsNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetTickerStatsNode.ts
index 50569294e..ab5c7c752 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetTickerStatsNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/GetTickerStatsNode.ts
@@ -11,7 +11,7 @@ import {
NodeConnectionType,
NodePropertyType,
} from '../../types';
-import { MarketDataBridge } from '../../adapters/MarketDataBridge';
+import { MarketDataBridge, DataProvider } from '../../adapters/MarketDataBridge';
export class GetTickerStatsNode implements INodeType {
description: INodeTypeDescription = {
@@ -133,7 +133,7 @@ export class GetTickerStatsNode implements INodeType {
async execute(this: IExecuteFunctions): Promise<NodeOutput> {
const useInputSymbols = this.getNodeParameter('useInputSymbols', 0) as boolean;
const statsType = this.getNodeParameter('statsType', 0) as string;
- const provider = this.getNodeParameter('provider', 0) as string;
+ const provider = this.getNodeParameter('provider', 0) as DataProvider;
const includeTechnical = this.getNodeParameter('includeTechnical', 0) as boolean;
const includeBeta = this.getNodeParameter('includeBeta', 0) as boolean;
@@ -160,14 +160,14 @@ export class GetTickerStatsNode implements INodeType {
}]];
}
- const bridge = new MarketDataBridge();
- const results: Array<{ json: Record<string, unknown> }> = [];
+
+ const results: Array<{ json: Record<string, any> }> = [];
for (const symbol of symbols) {
try {
- const stats = await bridge.getTickerStats(symbol, provider);
+ const stats = await MarketDataBridge.getTickerStats(symbol, provider);
- const result: Record<string, unknown> = {
+ const result: Record<string, any> = {
symbol,
statsType,
provider,
@@ -178,15 +178,12 @@ export class GetTickerStatsNode implements INodeType {
switch (statsType) {
case '24h':
result.stats24h = {
- open: stats.open,
- high: stats.high,
- low: stats.low,
- close: stats.close,
- volume: stats.volume,
- volumeWeightedAvg: stats.vwap,
- change: stats.change,
- changePercent: stats.changePercent,
- trades: stats.trades,
+ lastPrice: stats.lastPrice,
+ high: stats.highPrice24h,
+ low: stats.lowPrice24h,
+ volume: stats.volume24h,
+ change: stats.change24h,
+ changePercent: stats.changePercent24h,
};
break;
@@ -194,82 +191,81 @@ export class GetTickerStatsNode implements INodeType {
const periods = this.getNodeParameter('performancePeriods', 0) as string[];
result.performance = {};
for (const period of periods) {
- (result.performance as Record<string, unknown>)[period] = this.calculatePerformance(stats, period);
+ (result.performance as Record<string, any>)[period] = GetTickerStatsNode.calculatePerformance(stats, period);
}
break;
case 'ath':
- result.allTimeHigh = stats.ath || stats.high52Week;
- result.allTimeLow = stats.atl || stats.low52Week;
- result.athDate = stats.athDate;
- result.atlDate = stats.atlDate;
- result.fromAth = stats.price && stats.ath ? ((stats.price - stats.ath) / stats.ath * 100).toFixed(2) + '%' : null;
- result.fromAtl = stats.price && stats.atl ? ((stats.price - stats.atl) / stats.atl * 100).toFixed(2) + '%' : null;
+ result.allTimeHigh = null;
+ result.allTimeLow = null;
+ result.athDate = null;
+ result.atlDate = null;
+ result.fromAth = null;
+ result.fromAtl = null;
break;
case '52week':
result.week52 = {
- high: stats.high52Week,
- low: stats.low52Week,
- range: stats.high52Week && stats.low52Week ? stats.high52Week - stats.low52Week : null,
- percentFromHigh: stats.price && stats.high52Week ? ((stats.price - stats.high52Week) / stats.high52Week * 100).toFixed(2) : null,
- percentFromLow: stats.price && stats.low52Week ? ((stats.price - stats.low52Week) / stats.low52Week * 100).toFixed(2) : null,
+ high: null,
+ low: null,
+ range: null,
+ percentFromHigh: null,
+ percentFromLow: null,
};
break;
case 'volatility':
result.volatility = {
- daily: stats.volatility?.daily || this.estimateVolatility(stats, 'daily'),
- weekly: stats.volatility?.weekly || this.estimateVolatility(stats, 'weekly'),
- monthly: stats.volatility?.monthly || this.estimateVolatility(stats, 'monthly'),
- annual: stats.volatility?.annual || this.estimateVolatility(stats, 'annual'),
- atr: stats.atr,
- atrPercent: stats.price && stats.atr ? (stats.atr / stats.price * 100).toFixed(2) : null,
+ daily: GetTickerStatsNode.estimateVolatility(stats, 'daily'),
+ weekly: GetTickerStatsNode.estimateVolatility(stats, 'weekly'),
+ monthly: GetTickerStatsNode.estimateVolatility(stats, 'monthly'),
+ annual: GetTickerStatsNode.estimateVolatility(stats, 'annual'),
+ atr: null,
+ atrPercent: null,
};
break;
case 'volume':
result.volumeProfile = {
- current: stats.volume,
- average: stats.avgVolume,
- ratio: stats.volume && stats.avgVolume ? (stats.volume / stats.avgVolume).toFixed(2) : null,
- dollarVolume: stats.price && stats.volume ? stats.price * stats.volume : null,
- avgDollarVolume: stats.price && stats.avgVolume ? stats.price * stats.avgVolume : null,
+ current: stats.volume24h,
+ average: null,
+ ratio: null,
+ dollarVolume: stats.lastPrice && stats.volume24h ? stats.lastPrice * stats.volume24h : null,
+ avgDollarVolume: null,
};
break;
case 'all':
default:
result.stats24h = {
- open: stats.open,
- high: stats.high,
- low: stats.low,
- close: stats.close,
- volume: stats.volume,
- change: stats.change,
- changePercent: stats.changePercent,
+ lastPrice: stats.lastPrice,
+ high: stats.highPrice24h,
+ low: stats.lowPrice24h,
+ volume: stats.volume24h,
+ change: stats.change24h,
+ changePercent: stats.changePercent24h,
};
result.week52 = {
- high: stats.high52Week,
- low: stats.low52Week,
+ high: null,
+ low: null,
};
result.averages = {
- volume: stats.avgVolume,
- price50: stats.sma50,
- price200: stats.sma200,
+ volume: null,
+ price50: null,
+ price200: null,
};
break;
}
// Add technical levels if requested
if (includeTechnical) {
- result.technicalLevels = this.calculateTechnicalLevels(stats);
+ result.technicalLevels = GetTickerStatsNode.calculateTechnicalLevels(stats);
}
// Add beta if requested
if (includeBeta) {
const benchmark = this.getNodeParameter('benchmark', 0) as string;
- result.beta = stats.beta || 1.0;
+ result.beta = 1.0;
result.benchmark = benchmark;
}
@@ -288,7 +284,7 @@ export class GetTickerStatsNode implements INodeType {
return [results];
}
- private calculatePerformance(stats: any, period: string): Record<string, unknown> {
+ private static calculatePerformance(stats: any, period: string): Record<string, any> {
// Mock performance calculation - would use historical data in production
const mockReturns: Record<string, number> = {
'1d': -0.5,
@@ -308,7 +304,7 @@ export class GetTickerStatsNode implements INodeType {
};
}
- private estimateVolatility(stats: any, period: string): number {
+ private static estimateVolatility(stats: any, period: string): number {
// Estimate volatility from high-low range
const range = stats.high && stats.low ? (stats.high - stats.low) / stats.low : 0;
@@ -322,7 +318,7 @@ export class GetTickerStatsNode implements INodeType {
return parseFloat((range * 100 * (multipliers[period] || 1)).toFixed(2));
}
- private calculateTechnicalLevels(stats: any): Record<string, unknown> {
+ private static calculateTechnicalLevels(stats: any): Record<string, any> {
const high = stats.high || stats.close;
const low = stats.low || stats.close;
const close = stats.close;
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/StreamQuotesNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/StreamQuotesNode.ts
index 2f3812509..a08710e4c 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/StreamQuotesNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/marketData/StreamQuotesNode.ts
@@ -202,7 +202,7 @@ export class StreamQuotesNode implements INodeType {
json: {
type: 'streamSetup',
...streamConfig,
- websocketUrl: this.getWebSocketUrl(provider, symbols, streamType),
+ websocketUrl: StreamQuotesNode.getWebSocketUrl(provider, symbols, streamType),
timestamp: new Date().toISOString(),
executionId: this.getExecutionId(),
message: `Streaming ${symbols.join(', ')} via ${provider}`,
@@ -210,7 +210,7 @@ export class StreamQuotesNode implements INodeType {
}]];
}
- private getWebSocketUrl(provider: string, symbols: string[], streamType: string): string {
+ private static getWebSocketUrl(provider: string, symbols: string[], streamType: string): string {
switch (provider) {
case 'binance':
const streams = symbols.map(s => `${s.toLowerCase()}@${streamType}`).join('/');
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/CancelOrderNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/CancelOrderNode.ts
index 86f86e495..d630cc421 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/CancelOrderNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/CancelOrderNode.ts
@@ -124,12 +124,11 @@ export class CancelOrderNode implements INodeType {
const cancelMode = this.getNodeParameter('cancelMode', 0) as string;
const broker = this.getNodeParameter('broker', 0) as string;
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
- const auditLogger = new AuditLogger();
+
try {
- const results: Array<{ json: Record<string, unknown> }> = [];
+ const results: Array<{ json: Record<string, any> }> = [];
let orderIds: string[] = [];
switch (cancelMode) {
@@ -153,21 +152,21 @@ export class CancelOrderNode implements INodeType {
const cancelOnly = this.getNodeParameter('cancelOnly', 0) as string;
// Get open orders for symbol
- const orders = await this.getOpenOrders(tradingBridge, broker, isPaper);
- let filtered = orders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase());
+ const orders = await CancelOrderNode.getOpenOrders(broker, isPaper);
+ let filtered = orders.filter((o: any) => o.symbol.toUpperCase() === symbol.toUpperCase());
// Apply additional filter
if (cancelOnly === 'buy') {
- filtered = filtered.filter(o => o.side === 'BUY');
+ filtered = filtered.filter((o: any) => o.side === 'BUY');
} else if (cancelOnly === 'sell') {
- filtered = filtered.filter(o => o.side === 'SELL');
+ filtered = filtered.filter((o: any) => o.side === 'SELL');
} else if (cancelOnly === 'limit') {
- filtered = filtered.filter(o => o.orderType === 'LIMIT');
+ filtered = filtered.filter((o: any) => o.orderType === 'LIMIT');
} else if (cancelOnly === 'stop') {
- filtered = filtered.filter(o => o.orderType === 'SL' || o.orderType === 'SL-L');
+ filtered = filtered.filter((o: any) => o.orderType === 'SL' || o.orderType === 'SL-L');
}
- orderIds = filtered.map(o => o.orderId);
+ orderIds = filtered.map((o: any) => o.orderId);
break;
}
@@ -175,21 +174,21 @@ export class CancelOrderNode implements INodeType {
const cancelOnly = this.getNodeParameter('cancelOnly', 0) as string;
// Get all open orders
- const orders = await this.getOpenOrders(tradingBridge, broker, isPaper);
+ const orders = await CancelOrderNode.getOpenOrders(broker, isPaper);
let filtered = orders;
// Apply filter
if (cancelOnly === 'buy') {
- filtered = filtered.filter(o => o.side === 'BUY');
+ filtered = filtered.filter((o: any) => o.side === 'BUY');
} else if (cancelOnly === 'sell') {
- filtered = filtered.filter(o => o.side === 'SELL');
+ filtered = filtered.filter((o: any) => o.side === 'SELL');
} else if (cancelOnly === 'limit') {
- filtered = filtered.filter(o => o.orderType === 'LIMIT');
+ filtered = filtered.filter((o: any) => o.orderType === 'LIMIT');
} else if (cancelOnly === 'stop') {
- filtered = filtered.filter(o => o.orderType === 'SL' || o.orderType === 'SL-L');
+ filtered = filtered.filter((o: any) => o.orderType === 'SL' || o.orderType === 'SL-L');
}
- orderIds = filtered.map(o => o.orderId);
+ orderIds = filtered.map((o: any) => o.orderId);
break;
}
@@ -226,15 +225,15 @@ export class CancelOrderNode implements INodeType {
// Cancel each order
for (const orderId of orderIds) {
try {
- const result = await tradingBridge.cancelOrder(orderId, broker, isPaper);
+ const result = await TradingBridge.cancelOrder(orderId, broker as any);
// Log the cancellation
- await auditLogger.log({
- type: 'ORDER_CANCELLED' as any,
+ await AuditLogger.log({
+ actionType: 'ORDER_CANCELLED',
+ orderId,
+ paperTrading: isPaper,
details: {
- orderId,
broker,
- paperTrading: isPaper,
},
});
@@ -274,7 +273,7 @@ export class CancelOrderNode implements INodeType {
}
}
- private async getOpenOrders(bridge: TradingBridge, broker: string, isPaper: boolean): Promise<any[]> {
+ private static async getOpenOrders(broker: string, isPaper: boolean): Promise<any[]> {
// Mock implementation - would fetch real orders
return [
{ orderId: 'ORD001', symbol: 'AAPL', side: 'BUY', orderType: 'LIMIT', status: 'open' },
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ClosePositionNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ClosePositionNode.ts
index dd405d1de..07f881711 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ClosePositionNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ClosePositionNode.ts
@@ -178,12 +178,11 @@ export class ClosePositionNode implements INodeType {
const onlyProfitable = this.getNodeParameter('onlyProfitable', 0) as boolean;
const onlyIfLoss = this.getNodeParameter('onlyIfLoss', 0) as boolean;
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
try {
// Get current positions
- const positions = await tradingBridge.getPositions(broker, isPaper);
+ const positions = await TradingBridge.getPositions(broker as any);
// Determine which positions to close
let positionsToClose = positions;
@@ -207,19 +206,20 @@ export class ClosePositionNode implements INodeType {
}]];
}
- positionsToClose = positions.filter(p => p.symbol.toUpperCase() === symbol.toUpperCase());
+ positionsToClose = positions.filter((p: any) => p.symbol.toUpperCase() === symbol.toUpperCase());
}
// Filter by profit condition
if (onlyProfitable) {
- positionsToClose = positionsToClose.filter(p => p.pnl > 0);
+ positionsToClose = positionsToClose.filter((p: any) => (p.pnl || 0) > 0);
}
// Filter by loss condition
if (onlyIfLoss) {
const lossThreshold = this.getNodeParameter('lossThreshold', 0) as number;
- positionsToClose = positionsToClose.filter(p => {
- const pnlPercent = p.averagePrice > 0 ? ((p.lastPrice - p.averagePrice) / p.averagePrice) * 100 : 0;
+ positionsToClose = positionsToClose.filter((p: any) => {
+ const currentPrice = p.currentPrice || p.averagePrice;
+ const pnlPercent = p.averagePrice > 0 ? ((currentPrice - p.averagePrice) / p.averagePrice) * 100 : 0;
return pnlPercent < -lossThreshold;
});
}
@@ -236,7 +236,7 @@ export class ClosePositionNode implements INodeType {
}]];
}
- const results: Array<{ json: Record<string, unknown> }> = [];
+ const results: Array<{ json: Record<string, any> }> = [];
for (const position of positionsToClose) {
// Calculate quantity to close
@@ -256,7 +256,8 @@ export class ClosePositionNode implements INodeType {
}
case 'dollars': {
const dollarAmount = this.getNodeParameter('dollarAmount', 0) as number;
- closeQuantity = Math.floor(dollarAmount / position.lastPrice);
+ const currentPrice = (position as any).currentPrice || position.averagePrice;
+ closeQuantity = Math.floor(dollarAmount / currentPrice);
closeQuantity = Math.min(closeQuantity, positionQty);
break;
}
@@ -279,20 +280,23 @@ export class ClosePositionNode implements INodeType {
// Determine close side (opposite of position)
const closeSide = position.quantity > 0 ? 'SELL' : 'BUY';
- const estimatedValue = closeQuantity * position.lastPrice;
+ const currentPrice = (position as any).currentPrice || position.averagePrice;
+ const estimatedValue = closeQuantity * currentPrice;
// Request confirmation if enabled
if (requireConfirmation && !isPaper) {
- const confirmationService = new ConfirmationService();
- const confirmed = await confirmationService.requestTradeConfirmation({
- symbol: position.symbol,
- side: closeSide,
- quantity: closeQuantity,
- price: position.lastPrice,
- broker,
- estimatedValue,
- isClosing: true,
- });
+ const confirmed = await ConfirmationService.requestTradeConfirmation(
+ {
+ symbol: position.symbol,
+ side: closeSide as any,
+ quantity: closeQuantity,
+ price: currentPrice,
+ type: 'MARKET',
+ },
+ { valid: true, failed: [], warnings: [], passed: [], overallRisk: 'low', message: 'Position close approved' },
+ undefined,
+ isPaper
+ );
if (!confirmed) {
results.push({
@@ -313,29 +317,29 @@ export class ClosePositionNode implements INodeType {
? this.getNodeParameter('limitPrice', 0) as number
: undefined;
- const result = await tradingBridge.closePosition(
+ const result = await TradingBridge.closePosition(
position.symbol,
- closeQuantity,
- broker,
- isPaper
+ broker as any,
+ closeQuantity
);
// Log the close
- const auditLogger = new AuditLogger();
- await auditLogger.logOrder({
- orderId: result.orderId,
- symbol: position.symbol,
- side: closeSide as any,
- quantity: closeQuantity,
- price: position.lastPrice,
- status: result.status,
- broker,
- paperTrading: isPaper,
- action: 'close_position',
- });
+ await AuditLogger.logOrder(
+ 'ORDER_PLACED',
+ {
+ orderId: result.orderId || 'UNKNOWN',
+ symbol: position.symbol,
+ side: closeSide,
+ quantity: closeQuantity,
+ price: currentPrice,
+ status: result.status || 'UNKNOWN',
+ },
+ undefined,
+ isPaper
+ );
// Calculate realized P&L
- const realizedPnl = (position.lastPrice - position.averagePrice) * closeQuantity * (position.quantity > 0 ? 1 : -1);
+ const realizedPnl = (currentPrice - position.averagePrice) * closeQuantity * (position.quantity > 0 ? 1 : -1);
results.push({
json: {
@@ -345,7 +349,7 @@ export class ClosePositionNode implements INodeType {
side: closeSide,
quantityClosed: closeQuantity,
remainingQuantity: positionQty - closeQuantity,
- price: position.lastPrice,
+ price: currentPrice,
realizedPnl,
realizedPnlPercent: ((realizedPnl / (closeQuantity * position.averagePrice)) * 100).toFixed(2) + '%',
status: result.status,
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetBalanceNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetBalanceNode.ts
index 11b8fb83d..f64ec2b25 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetBalanceNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetBalanceNode.ts
@@ -83,25 +83,20 @@ export class GetBalanceNode implements INodeType {
const includePnl = this.getNodeParameter('includePnl', 0) as boolean;
const currency = this.getNodeParameter('currency', 0) as string;
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
try {
- const balance = await tradingBridge.getBalance(broker, isPaper);
+ const balance = await TradingBridge.getBalance(broker as any, currency);
- const result: Record<string, unknown> = {
+ const result: Record<string, any> = {
broker,
paperTrading: isPaper,
currency,
// Core balance info
- cashBalance: balance.cashBalance,
- availableBalance: balance.availableBalance,
- buyingPower: balance.buyingPower,
-
- // Portfolio value
- portfolioValue: balance.portfolioValue,
- totalEquity: balance.totalEquity,
+ available: balance.available,
+ used: balance.used,
+ total: balance.total,
fetchedAt: new Date().toISOString(),
};
@@ -109,34 +104,34 @@ export class GetBalanceNode implements INodeType {
// Add margin details if requested
if (includeMargin) {
result.margin = {
- usedMargin: balance.usedMargin || 0,
- availableMargin: balance.availableMargin || balance.availableBalance,
- marginLevel: balance.marginLevel || 100,
- leverage: balance.leverage || 1,
- maintenanceMargin: balance.maintenanceMargin || 0,
- marginCallLevel: balance.marginCallLevel || 50,
- isMarginCall: balance.marginLevel ? balance.marginLevel < (balance.marginCallLevel || 50) : false,
+ usedMargin: balance.marginUsed || 0,
+ availableMargin: balance.margin || balance.available,
+ marginLevel: 100,
+ leverage: 1,
+ maintenanceMargin: 0,
+ marginCallLevel: 50,
+ isMarginCall: false,
};
}
// Add P&L summary if requested
if (includePnl) {
result.pnl = {
- unrealizedPnl: balance.unrealizedPnl || 0,
- realizedPnlToday: balance.realizedPnlToday || 0,
- realizedPnlWeek: balance.realizedPnlWeek || 0,
- realizedPnlMonth: balance.realizedPnlMonth || 0,
- realizedPnlYear: balance.realizedPnlYear || 0,
- returnToday: balance.returnToday || '0%',
- returnWeek: balance.returnWeek || '0%',
- returnMonth: balance.returnMonth || '0%',
- returnYear: balance.returnYear || '0%',
+ unrealizedPnl: 0,
+ realizedPnlToday: 0,
+ realizedPnlWeek: 0,
+ realizedPnlMonth: 0,
+ realizedPnlYear: 0,
+ returnToday: '0%',
+ returnWeek: '0%',
+ returnMonth: '0%',
+ returnYear: '0%',
};
}
// Add crypto-specific fields if applicable
if (['binance', 'kraken', 'coinbase'].includes(broker)) {
- result.cryptoBalances = balance.cryptoBalances || {};
+ result.cryptoBalances = {};
}
return [[{ json: result }]];
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetHoldingsNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetHoldingsNode.ts
index d02950572..2016f55e5 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetHoldingsNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetHoldingsNode.ts
@@ -110,11 +110,10 @@ export class GetHoldingsNode implements INodeType {
const sortBy = this.getNodeParameter('sortBy', 0) as string;
const outputMode = this.getNodeParameter('outputMode', 0) as string;
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
try {
- let holdings = await tradingBridge.getHoldings(broker, isPaper);
+ let holdings = await TradingBridge.getHoldings(broker as any);
// Filter by symbol if specified
if (filterSymbol) {
@@ -125,11 +124,11 @@ export class GetHoldingsNode implements INodeType {
// Calculate market values if requested
if (includeMarketValue) {
for (const holding of holdings) {
- holding.marketValue = holding.quantity * holding.lastPrice;
- holding.costBasis = holding.quantity * holding.averagePrice;
- holding.unrealizedPnl = holding.marketValue - holding.costBasis;
- holding.unrealizedPnlPercent = holding.costBasis !== 0
- ? ((holding.unrealizedPnl / holding.costBasis) * 100).toFixed(2)
+ (holding as any).marketValue = holding.quantity * (holding.currentPrice || holding.averagePrice);
+ (holding as any).costBasis = holding.quantity * holding.averagePrice;
+ (holding as any).unrealizedPnl = (holding as any).marketValue - (holding as any).costBasis;
+ (holding as any).unrealizedPnlPercent = (holding as any).costBasis !== 0
+ ? (((holding as any).unrealizedPnl / (holding as any).costBasis) * 100).toFixed(2)
: '0';
}
}
@@ -148,30 +147,30 @@ export class GetHoldingsNode implements INodeType {
for (const holding of holdings) {
const sectorInfo = sectorMap[holding.symbol] || { sector: 'Unknown', industry: 'Unknown' };
- holding.sector = sectorInfo.sector;
- holding.industry = sectorInfo.industry;
+ (holding as any).sector = sectorInfo.sector;
+ (holding as any).industry = sectorInfo.industry;
}
}
// Add mock dividend data if requested
if (includeDividends) {
for (const holding of holdings) {
- holding.annualDividend = (holding.lastPrice * 0.02).toFixed(2); // Mock 2% yield
- holding.dividendYield = '2.00%';
- holding.exDividendDate = null;
+ (holding as any).annualDividend = ((holding.currentPrice || holding.averagePrice) * 0.02).toFixed(2); // Mock 2% yield
+ (holding as any).dividendYield = '2.00%';
+ (holding as any).exDividendDate = null;
}
}
// Sort holdings
switch (sortBy) {
case 'value':
- holdings.sort((a, b) => (b.marketValue || 0) - (a.marketValue || 0));
+ holdings.sort((a, b) => (b.currentValue || 0) - (a.currentValue || 0));
break;
case 'pnl':
- holdings.sort((a, b) => (b.unrealizedPnl || 0) - (a.unrealizedPnl || 0));
+ holdings.sort((a, b) => (b.pnl || 0) - (a.pnl || 0));
break;
case 'pnlPercent':
- holdings.sort((a, b) => parseFloat(b.unrealizedPnlPercent || '0') - parseFloat(a.unrealizedPnlPercent || '0'));
+ holdings.sort((a, b) => (b.pnlPercent || 0) - (a.pnlPercent || 0));
break;
case 'symbol':
holdings.sort((a, b) => a.symbol.localeCompare(b.symbol));
@@ -182,16 +181,16 @@ export class GetHoldingsNode implements INodeType {
}
// Calculate portfolio summary
- const totalValue = holdings.reduce((sum, h) => sum + (h.marketValue || 0), 0);
- const totalCost = holdings.reduce((sum, h) => sum + (h.costBasis || 0), 0);
+ const totalValue = holdings.reduce((sum, h) => sum + (h.currentValue || 0), 0);
+ const totalCost = holdings.reduce((sum, h) => sum + (h.investedValue || 0), 0);
const totalPnl = totalValue - totalCost;
// Calculate sector allocation
const sectorAllocation: Record<string, number> = {};
if (includeSector) {
for (const holding of holdings) {
- const sector = holding.sector || 'Unknown';
- sectorAllocation[sector] = (sectorAllocation[sector] || 0) + (holding.marketValue || 0);
+ const sector = (holding as any).sector || 'Unknown';
+ sectorAllocation[sector] = (sectorAllocation[sector] || 0) + (holding.currentValue || 0);
}
// Convert to percentages
for (const sector of Object.keys(sectorAllocation)) {
@@ -205,9 +204,9 @@ export class GetHoldingsNode implements INodeType {
totalCostBasis: totalCost,
totalUnrealizedPnl: totalPnl,
totalUnrealizedPnlPercent: totalCost !== 0 ? ((totalPnl / totalCost) * 100).toFixed(2) + '%' : '0%',
- profitableHoldings: holdings.filter(h => (h.unrealizedPnl || 0) > 0).length,
- losingHoldings: holdings.filter(h => (h.unrealizedPnl || 0) < 0).length,
- topHolding: holdings[0] ? { symbol: holdings[0].symbol, weight: ((holdings[0].marketValue || 0) / totalValue * 100).toFixed(2) + '%' } : null,
+ profitableHoldings: holdings.filter(h => (h.pnl || 0) > 0).length,
+ losingHoldings: holdings.filter(h => (h.pnl || 0) < 0).length,
+ topHolding: holdings[0] ? { symbol: holdings[0].symbol, weight: ((holdings[0].currentValue || 0) / totalValue * 100).toFixed(2) + '%' } : null,
sectorAllocation: includeSector ? sectorAllocation : undefined,
broker,
paperTrading: isPaper,
@@ -216,8 +215,8 @@ export class GetHoldingsNode implements INodeType {
// Calculate weights for each holding
for (const holding of holdings) {
- holding.portfolioWeight = totalValue > 0
- ? ((holding.marketValue || 0) / totalValue * 100).toFixed(2) + '%'
+ (holding as any).portfolioWeight = totalValue > 0
+ ? ((holding.currentValue || 0) / totalValue * 100).toFixed(2) + '%'
: '0%';
}
@@ -244,7 +243,7 @@ export class GetHoldingsNode implements INodeType {
},
}]];
}
- return [holdings.map(h => ({ json: h }))];
+ return [holdings.map(h => ({ json: h as any }))];
}
} catch (error) {
return [[{
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetOrdersNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetOrdersNode.ts
index a50743658..87c53de83 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetOrdersNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetOrdersNode.ts
@@ -131,27 +131,26 @@ export class GetOrdersNode implements INodeType {
const includeTradeDetails = this.getNodeParameter('includeTradeDetails', 0) as boolean;
const sortOrder = this.getNodeParameter('sortOrder', 0) as string;
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
try {
// Mock order data - would come from actual broker API
- let orders = this.getMockOrders(broker, isPaper);
+ let orders: any[] = GetOrdersNode.getMockOrders(broker, isPaper);
// Filter by status
if (orderStatus !== 'all') {
- orders = orders.filter(o => o.status.toLowerCase() === orderStatus.toLowerCase());
+ orders = orders.filter((o: any) => o.status.toLowerCase() === orderStatus.toLowerCase());
}
// Filter by symbol
if (filterSymbol) {
const symbols = filterSymbol.split(',').map(s => s.trim().toUpperCase());
- orders = orders.filter(o => symbols.includes(o.symbol.toUpperCase()));
+ orders = orders.filter((o: any) => symbols.includes(o.symbol.toUpperCase()));
}
// Filter by side
if (orderSide !== 'all') {
- orders = orders.filter(o => o.side.toLowerCase() === orderSide.toLowerCase());
+ orders = orders.filter((o: any) => o.side.toLowerCase() === orderSide.toLowerCase());
}
// Filter by time period
@@ -165,11 +164,11 @@ export class GetOrdersNode implements INodeType {
if (timePeriod !== 'all' && periodMs[timePeriod]) {
const cutoff = new Date(now.getTime() - periodMs[timePeriod]);
- orders = orders.filter(o => new Date(o.timestamp) >= cutoff);
+ orders = orders.filter((o: any) => new Date(o.timestamp) >= cutoff);
}
// Sort orders
- orders.sort((a, b) => {
+ orders.sort((a: any, b: any) => {
const timeA = new Date(a.timestamp).getTime();
const timeB = new Date(b.timestamp).getTime();
return sortOrder === 'desc' ? timeB - timeA : timeA - timeB;
@@ -181,13 +180,13 @@ export class GetOrdersNode implements INodeType {
// Calculate summary statistics
const summary = {
totalOrders: orders.length,
- openOrders: orders.filter(o => o.status === 'open' || o.status === 'pending').length,
- filledOrders: orders.filter(o => o.status === 'filled').length,
- cancelledOrders: orders.filter(o => o.status === 'cancelled').length,
- rejectedOrders: orders.filter(o => o.status === 'rejected').length,
- buyOrders: orders.filter(o => o.side === 'BUY').length,
- sellOrders: orders.filter(o => o.side === 'SELL').length,
- totalVolume: orders.reduce((sum, o) => sum + (o.filledQuantity || 0) * (o.averagePrice || o.price), 0),
+ openOrders: orders.filter((o: any) => o.status === 'open' || o.status === 'pending').length,
+ filledOrders: orders.filter((o: any) => o.status === 'filled').length,
+ cancelledOrders: orders.filter((o: any) => o.status === 'cancelled').length,
+ rejectedOrders: orders.filter((o: any) => o.status === 'rejected').length,
+ buyOrders: orders.filter((o: any) => o.side === 'BUY').length,
+ sellOrders: orders.filter((o: any) => o.side === 'SELL').length,
+ totalVolume: orders.reduce((sum: any, o: any) => sum + (o.filledQuantity || 0) * (o.averagePrice || o.price), 0),
broker,
paperTrading: isPaper,
period: timePeriod,
@@ -225,7 +224,7 @@ export class GetOrdersNode implements INodeType {
}
}
- private getMockOrders(broker: string, isPaper: boolean): any[] {
+ private static getMockOrders(broker: string, isPaper: boolean): any[] {
const now = new Date();
return [
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetPositionsNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetPositionsNode.ts
index 9ad6659c0..a9f5e50ad 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetPositionsNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/GetPositionsNode.ts
@@ -111,11 +111,10 @@ export class GetPositionsNode implements INodeType {
const includeMarketValue = this.getNodeParameter('includeMarketValue', 0) as boolean;
const outputMode = this.getNodeParameter('outputMode', 0) as string;
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
- try {
- let positions = await tradingBridge.getPositions(broker, isPaper);
+ try{
+ let positions = await TradingBridge.getPositions(broker as any);
// Filter by symbol if specified
if (filterSymbol) {
@@ -132,10 +131,10 @@ export class GetPositionsNode implements INodeType {
positions = positions.filter(p => p.quantity < 0);
break;
case 'profit':
- positions = positions.filter(p => p.pnl > 0);
+ positions = positions.filter(p => (p.pnl || 0) > 0);
break;
case 'loss':
- positions = positions.filter(p => p.pnl < 0);
+ positions = positions.filter(p => (p.pnl || 0) < 0);
break;
}
@@ -147,11 +146,11 @@ export class GetPositionsNode implements INodeType {
// Calculate market values if requested
if (includeMarketValue) {
for (const pos of positions) {
- pos.marketValue = pos.quantity * pos.lastPrice;
- pos.costBasis = pos.quantity * pos.averagePrice;
- pos.unrealizedPnl = pos.marketValue - pos.costBasis;
- pos.unrealizedPnlPercent = pos.costBasis !== 0
- ? ((pos.unrealizedPnl / pos.costBasis) * 100).toFixed(2) + '%'
+ (pos as any).marketValue = pos.quantity * (pos.currentPrice || pos.averagePrice);
+ (pos as any).costBasis = pos.quantity * pos.averagePrice;
+ (pos as any).unrealizedPnl = (pos as any).marketValue - (pos as any).costBasis;
+ (pos as any).unrealizedPnlPercent = (pos as any).costBasis !== 0
+ ? (((pos as any).unrealizedPnl / (pos as any).costBasis) * 100).toFixed(2) + '%'
: '0%';
}
}
@@ -161,13 +160,13 @@ export class GetPositionsNode implements INodeType {
totalPositions: positions.length,
longPositions: positions.filter(p => p.quantity > 0).length,
shortPositions: positions.filter(p => p.quantity < 0).length,
- totalMarketValue: positions.reduce((sum, p) => sum + (p.marketValue || 0), 0),
- totalCostBasis: positions.reduce((sum, p) => sum + (p.costBasis || 0), 0),
- totalUnrealizedPnl: positions.reduce((sum, p) => sum + (p.unrealizedPnl || 0), 0),
- profitablePositions: positions.filter(p => (p.unrealizedPnl || 0) > 0).length,
- losingPositions: positions.filter(p => (p.unrealizedPnl || 0) < 0).length,
+ totalMarketValue: positions.reduce((sum, p) => sum + ((p as any).marketValue || 0), 0),
+ totalCostBasis: positions.reduce((sum, p) => sum + ((p as any).costBasis || 0), 0),
+ totalUnrealizedPnl: positions.reduce((sum, p) => sum + ((p as any).unrealizedPnl || 0), 0),
+ profitablePositions: positions.filter(p => ((p as any).unrealizedPnl || 0) > 0).length,
+ losingPositions: positions.filter(p => ((p as any).unrealizedPnl || 0) < 0).length,
largestPosition: positions.reduce((max, p) =>
- Math.abs(p.marketValue || 0) > Math.abs(max?.marketValue || 0) ? p : max, positions[0]),
+ Math.abs((p as any).marketValue || 0) > Math.abs((max as any)?.marketValue || 0) ? p : max, positions[0]) as any,
broker,
paperTrading: isPaper,
fetchedAt: new Date().toISOString(),
@@ -197,7 +196,7 @@ export class GetPositionsNode implements INodeType {
},
}]];
}
- return [positions.map(p => ({ json: p }))];
+ return [positions.map(p => ({ json: p as any }))];
}
} catch (error) {
return [[{
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ModifyOrderNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ModifyOrderNode.ts
index 583e0e39d..d7c06e82f 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ModifyOrderNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/ModifyOrderNode.ts
@@ -155,12 +155,11 @@ export class ModifyOrderNode implements INodeType {
}]];
}
- const tradingBridge = new TradingBridge();
const isPaper = broker === 'paper';
try {
// Build modification request
- const modifications: Record<string, unknown> = {};
+ const modifications: Record<string, any> = {};
switch (modificationType) {
case 'price':
@@ -178,17 +177,17 @@ export class ModifyOrderNode implements INodeType {
break;
}
- const result = await tradingBridge.modifyOrder(orderId, modifications, broker, isPaper);
+ const result = await TradingBridge.modifyOrder(orderId, modifications as any, broker as any);
// Log the modification
- const auditLogger = new AuditLogger();
- await auditLogger.log({
- type: 'ORDER_MODIFIED' as any,
+
+ await AuditLogger.log({
+ actionType: 'ORDER_MODIFIED',
+ orderId,
+ paperTrading: isPaper,
details: {
- orderId,
- modifications,
+ modifications: modifications as any,
broker,
- paperTrading: isPaper,
},
});
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/PlaceOrderNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/PlaceOrderNode.ts
index 93b88fc94..c75f85fd7 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/PlaceOrderNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/trading/PlaceOrderNode.ts
@@ -11,9 +11,9 @@ import {
NodeConnectionType,
NodePropertyType,
} from '../../types';
-import { TradingBridge, OrderSide, OrderType, ProductType, Validity } from '../../adapters/TradingBridge';
+import { TradingBridge, OrderSide, OrderType, ProductType, OrderValidity } from '../../adapters/TradingBridge';
import { RiskManager } from '../../safety/RiskManager';
-import { AuditLogger, LogType } from '../../safety/AuditLogger';
+import { AuditLogger } from '../../safety/AuditLogger';
import { ConfirmationService } from '../../safety/ConfirmationService';
export class PlaceOrderNode implements INodeType {
@@ -237,18 +237,13 @@ export class PlaceOrderNode implements INodeType {
],
};
- private tradingBridge = new TradingBridge();
- private riskManager = new RiskManager();
- private auditLogger = new AuditLogger();
- private confirmationService = new ConfirmationService();
-
async execute(this: IExecuteFunctions): Promise<NodeOutput> {
const useInputSymbol = this.getNodeParameter('useInputSymbol', 0) as boolean;
const side = this.getNodeParameter('side', 0) as OrderSide;
const orderType = this.getNodeParameter('orderType', 0) as OrderType;
const quantityType = this.getNodeParameter('quantityType', 0) as string;
const productType = this.getNodeParameter('productType', 0) as ProductType;
- const validity = this.getNodeParameter('validity', 0) as Validity;
+ const validity = this.getNodeParameter('validity', 0) as OrderValidity;
const broker = this.getNodeParameter('broker', 0) as string;
const requireConfirmation = this.getNodeParameter('requireConfirmation', 0) as boolean;
const validateRisk = this.getNodeParameter('validateRisk', 0) as boolean;
@@ -303,10 +298,10 @@ export class PlaceOrderNode implements INodeType {
let limitPrice: number | undefined;
let stopPrice: number | undefined;
- if (orderType === 'LIMIT' || orderType === 'SL-L') {
+ if (orderType === 'LIMIT') {
limitPrice = this.getNodeParameter('limitPrice', 0) as number;
}
- if (orderType === 'SL' || orderType === 'SL-L') {
+ if (orderType === 'STOP_LOSS' || orderType === 'STOP_LOSS_MARKET') {
stopPrice = this.getNodeParameter('stopPrice', 0) as number;
}
@@ -327,38 +322,44 @@ export class PlaceOrderNode implements INodeType {
tag: tag || `workflow_${this.getExecutionId()}`,
};
+ const isPaper = broker === 'paper';
+
// Validate against risk limits if enabled
if (validateRisk) {
- const riskManager = new RiskManager();
- const validation = riskManager.validateOrder({
- symbol,
- side,
- quantity,
- price: estimatedPrice,
- orderType,
- });
+
+ const validation = await RiskManager.validateOrder(
+ orderRequest as any,
+ [],
+ { currency: 'USD', available: 100000, used: 0, total: 100000 },
+ estimatedPrice
+ );
if (!validation.valid) {
// Log the blocked order
- const auditLogger = new AuditLogger();
- await auditLogger.logOrder({
- orderId: 'BLOCKED',
- symbol,
- side,
- quantity,
- price: estimatedPrice,
- status: 'blocked',
- broker,
- reason: validation.errors.join(', '),
- });
+
+ await AuditLogger.logOrder(
+ 'RISK_CHECK_FAILED' as any,
+ {
+ orderId: 'BLOCKED',
+ symbol,
+ side,
+ quantity,
+ price: estimatedPrice,
+ status: 'blocked',
+ broker,
+ reason: validation.failed.map((f: any) => f.message).join(', '),
+ },
+ undefined,
+ isPaper
+ );
return [[{
json: {
success: false,
blocked: true,
reason: 'Risk validation failed',
- errors: validation.errors,
- warnings: validation.warnings,
+ errors: validation.failed.map((f: any) => f.message),
+ warnings: validation.warnings.map((w: any) => w.message),
order: orderRequest,
timestamp: new Date().toISOString(),
},
@@ -368,15 +369,18 @@ export class PlaceOrderNode implements INodeType {
// Request confirmation if enabled (and not paper trading)
if (requireConfirmation && broker !== 'paper') {
- const confirmationService = new ConfirmationService();
- const confirmed = await confirmationService.requestTradeConfirmation({
- symbol,
- side,
- quantity,
- price: estimatedPrice,
- broker,
- estimatedValue,
- });
+ const confirmed = await ConfirmationService.requestTradeConfirmation(
+ {
+ symbol,
+ side,
+ quantity,
+ price: estimatedPrice,
+ type: orderType,
+ },
+ { valid: true, failed: [], warnings: [], passed: [], overallRisk: 'low', message: 'Trade approved' },
+ undefined,
+ isPaper
+ );
if (!confirmed) {
return [[{
@@ -392,38 +396,38 @@ export class PlaceOrderNode implements INodeType {
}
// Execute the order
- const tradingBridge = new TradingBridge();
- const isPaper = broker === 'paper';
-
try {
- const result = await tradingBridge.placeOrder(
+ const result = await TradingBridge.placeOrder(
{
symbol,
side,
- orderType,
+ type: orderType,
quantity,
price: limitPrice,
triggerPrice: stopPrice,
- productType,
+ product: productType,
validity,
tag: orderRequest.tag,
- },
- broker,
- isPaper
+ } as any,
+ broker as any
);
// Log the order
- const auditLogger = new AuditLogger();
- await auditLogger.logOrder({
- orderId: result.orderId,
- symbol,
- side,
- quantity,
- price: estimatedPrice,
- status: result.status,
- broker,
- paperTrading: isPaper,
- });
+
+ await AuditLogger.logOrder(
+ 'ORDER_PLACED',
+ {
+ orderId: result.orderId || 'UNKNOWN',
+ symbol,
+ side,
+ quantity,
+ price: estimatedPrice,
+ status: result.status || 'UNKNOWN',
+ broker,
+ },
+ undefined,
+ isPaper
+ );
// Handle stop loss / take profit if configured
const stopLossPercent = this.getNodeParameter('stopLossPercent', 0) as number;
@@ -461,7 +465,7 @@ export class PlaceOrderNode implements INodeType {
side,
quantity,
orderType,
- price: limitPrice || result.price,
+ price: limitPrice || result.filledPrice || estimatedPrice,
status: result.status,
broker,
paperTrading: isPaper,
@@ -474,17 +478,22 @@ export class PlaceOrderNode implements INodeType {
}]];
} catch (error) {
// Log the error
- const auditLogger = new AuditLogger();
- await auditLogger.logOrder({
- orderId: 'ERROR',
- symbol,
- side,
- quantity,
- price: estimatedPrice,
- status: 'error',
- broker,
- reason: error instanceof Error ? error.message : 'Unknown error',
- });
+
+ await AuditLogger.logOrder(
+ 'NODE_FAILED' as any,
+ {
+ orderId: 'ERROR',
+ symbol,
+ side,
+ quantity,
+ price: estimatedPrice,
+ status: 'error',
+ broker,
+ reason: error instanceof Error ? error.message : 'Unknown error',
+ },
+ undefined,
+ isPaper
+ );
return [[{
json: {
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/MarketEventTriggerNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/MarketEventTriggerNode.ts
index 27d5fcc2c..17ed45237 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/MarketEventTriggerNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/MarketEventTriggerNode.ts
@@ -189,7 +189,7 @@ export class MarketEventTriggerNode implements INodeType {
};
// Market hours configuration
- private readonly marketHours: Record<string, { open: string; close: string; timezone: string; preMarket?: string; afterHours?: string }> = {
+ private static readonly marketHours: Record<string, { open: string; close: string; timezone: string; preMarket?: string; afterHours?: string }> = {
NYSE: { open: '09:30', close: '16:00', timezone: 'America/New_York', preMarket: '04:00', afterHours: '20:00' },
NSE: { open: '09:15', close: '15:30', timezone: 'Asia/Kolkata', preMarket: '09:00' },
BSE: { open: '09:15', close: '15:30', timezone: 'Asia/Kolkata', preMarket: '09:00' },
@@ -225,7 +225,7 @@ export class MarketEventTriggerNode implements INodeType {
case 'preMarketStart':
case 'afterHoursStart': {
const exchange = this.getNodeParameter('exchange', 0) as string;
- const hours = this.marketHours[exchange];
+ const hours = MarketEventTriggerNode.marketHours[exchange];
triggerConfig.exchange = exchange;
triggerConfig.timezone = hours.timezone;
@@ -243,7 +243,7 @@ export class MarketEventTriggerNode implements INodeType {
description = `${exchange} after-hours at ${hours.afterHours} ${hours.timezone}`;
}
- nextTrigger = this.getNextMarketEvent(exchange, eventType, offsetMinutes);
+ nextTrigger = MarketEventTriggerNode.getNextMarketEvent(exchange, eventType, offsetMinutes);
break;
}
@@ -277,13 +277,13 @@ export class MarketEventTriggerNode implements INodeType {
case 'quarterEnd': {
description = 'Quarter end';
- nextTrigger = this.getNextQuarterEnd();
+ nextTrigger = MarketEventTriggerNode.getNextQuarterEnd();
break;
}
case 'monthEnd': {
description = 'Month end';
- nextTrigger = this.getNextMonthEnd();
+ nextTrigger = MarketEventTriggerNode.getNextMonthEnd();
break;
}
@@ -313,8 +313,8 @@ export class MarketEventTriggerNode implements INodeType {
}]];
}
- private getNextMarketEvent(exchange: string, eventType: string, offsetMinutes: number): Date {
- const hours = this.marketHours[exchange];
+ private static getNextMarketEvent(exchange: string, eventType: string, offsetMinutes: number): Date {
+ const hours = MarketEventTriggerNode.marketHours[exchange];
const now = new Date();
const next = new Date(now);
@@ -340,7 +340,7 @@ export class MarketEventTriggerNode implements INodeType {
return next;
}
- private getNextQuarterEnd(): Date {
+ private static getNextQuarterEnd(): Date {
const now = new Date();
const month = now.getMonth();
const year = now.getFullYear();
@@ -359,7 +359,7 @@ export class MarketEventTriggerNode implements INodeType {
return new Date(year + 1, 2 + 1, 0);
}
- private getNextMonthEnd(): Date {
+ private static getNextMonthEnd(): Date {
const now = new Date();
const currentMonthEnd = new Date(now.getFullYear(), now.getMonth() + 1, 0);
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/NewsEventTriggerNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/NewsEventTriggerNode.ts
index 7f054be37..dc4e5b458 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/NewsEventTriggerNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/NewsEventTriggerNode.ts
@@ -262,12 +262,12 @@ export class NewsEventTriggerNode implements INodeType {
timestamp: new Date().toISOString(),
executionId: this.getExecutionId(),
status: 'monitoring',
- message: `Monitoring ${symbols.join(', ')} for ${this.getEventTypeLabel(eventType)} events`,
+ message: `Monitoring ${symbols.join(', ')} for ${NewsEventTriggerNode.getEventTypeLabel(eventType)} events`,
},
}]];
}
- private getEventTypeLabel(eventType: string): string {
+ private static getEventTypeLabel(eventType: string): string {
const labels: Record<string, string> = {
news: 'news',
earnings: 'earnings',
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/PriceAlertTriggerNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/PriceAlertTriggerNode.ts
index 609f9de72..830c827a5 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/PriceAlertTriggerNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/PriceAlertTriggerNode.ts
@@ -201,12 +201,12 @@ export class PriceAlertTriggerNode implements INodeType {
timestamp: new Date().toISOString(),
executionId: this.getExecutionId(),
status: 'monitoring',
- message: `Monitoring ${symbol} for ${this.formatCondition(condition, triggerConfig)}`,
+ message: `Monitoring ${symbol} for ${PriceAlertTriggerNode.formatCondition(condition, triggerConfig)}`,
},
}]];
}
- private formatCondition(condition: string, config: any): string {
+ private static formatCondition(condition: string, config: any): string {
switch (condition) {
case 'above':
return `price > $${config.targetPrice}`;
diff --git a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/ScheduleTriggerNode.ts b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/ScheduleTriggerNode.ts
index f6fc56440..a867d817e 100644
--- a/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/ScheduleTriggerNode.ts
+++ b/fincept-terminal-desktop/src/services/nodeSystem/nodes/triggers/ScheduleTriggerNode.ts
@@ -11,6 +11,7 @@ import {
NodeConnectionType,
NodePropertyType,
} from '../../types';
+import { MarketEventTriggerNode } from './MarketEventTriggerNode';
export class ScheduleTriggerNode implements INodeType {
description: INodeTypeDescription = {
@@ -161,22 +162,22 @@ export class ScheduleTriggerNode implements INodeType {
const time = this.getNodeParameter('time', 0) as string;
const [hour, minute] = time.split(':').map(Number);
cronExpression = `${minute} ${hour} * * *`;
- nextRun = this.getNextDailyRun(hour, minute, timezone);
+ nextRun = ScheduleTriggerNode.getNextDailyRun(hour, minute, timezone);
break;
case 'everyWeek':
const daysOfWeek = this.getNodeParameter('daysOfWeek', 0) as string[];
cronExpression = `0 9 * * ${daysOfWeek.join(',')}`;
- nextRun = this.getNextWeeklyRun(daysOfWeek, timezone);
+ nextRun = ScheduleTriggerNode.getNextWeeklyRun(daysOfWeek, timezone);
break;
case 'marketOpen':
const openExchange = this.getNodeParameter('exchange', 0) as string;
- cronExpression = this.getMarketOpenCron(openExchange);
- nextRun = this.getNextMarketOpen(openExchange);
+ cronExpression = ScheduleTriggerNode.getMarketOpenCron(openExchange);
+ nextRun = ScheduleTriggerNode.getNextMarketOpen(openExchange);
break;
case 'marketClose':
const closeExchange = this.getNodeParameter('exchange', 0) as string;
- cronExpression = this.getMarketCloseCron(closeExchange);
- nextRun = this.getNextMarketClose(closeExchange);
+ cronExpression = ScheduleTriggerNode.getMarketCloseCron(closeExchange);
+ nextRun = ScheduleTriggerNode.getNextMarketClose(closeExchange);
break;
case 'cron':
cronExpression = this.getNodeParameter('cronExpression', 0) as string;
@@ -201,7 +202,7 @@ export class ScheduleTriggerNode implements INodeType {
}]];
}
- private getNextDailyRun(hour: number, minute: number, timezone: string): Date {
+ private static getNextDailyRun(hour: number, minute: number, timezone: string): Date {
const now = new Date();
const next = new Date(now);
next.setHours(hour, minute, 0, 0);
@@ -211,7 +212,7 @@ export class ScheduleTriggerNode implements INodeType {
return next;
}
- private getNextWeeklyRun(days: string[], timezone: string): Date {
+ private static getNextWeeklyRun(days: string[], timezone: string): Date {
const now = new Date();
const currentDay = now.getDay();
const daysNum = days.map(Number).sort((a, b) => a - b);
@@ -232,7 +233,7 @@ export class ScheduleTriggerNode implements INodeType {
return next;
}
- private getMarketOpenCron(exchange: string): string {
+ private static getMarketOpenCron(exchange: string): string {
switch (exchange) {
case 'NYSE': return '30 9 * * 1-5'; // 9:30 AM ET
case 'NSE': return '15 9 * * 1-5'; // 9:15 AM IST
@@ -242,7 +243,7 @@ export class ScheduleTriggerNode implements INodeType {
}
}
- private getMarketCloseCron(exchange: string): string {
+ private static getMarketCloseCron(exchange: string): string {
switch (exchange) {
case 'NYSE': return '0 16 * * 1-5'; // 4:00 PM ET
case 'NSE': return '30 15 * * 1-5'; // 3:30 PM IST
@@ -252,7 +253,7 @@ export class ScheduleTriggerNode implements INodeType {
}
}
- private getNextMarketOpen(exchange: string): Date {
+ private static getNextMarketOpen(exchange: string): Date {
const now = new Date();
const next = new Date(now);
@@ -282,7 +283,7 @@ export class ScheduleTriggerNode implements INodeType {
return next;
}
- private getNextMarketClose(exchange: string): Date {
+ private static getNextMarketClose(exchange: string): Date {
const now = new Date();
const next = new Date(now);