nascoder
Version:
🚀 AI-powered conversational development assistant CLI with Azure AI integration, subscription management, and enterprise-grade features
414 lines (359 loc) • 11.9 kB
JavaScript
/*
* nascoder AI Engine - Proprietary
* Copyright (c) 2025 nascoder Technologies
* Unauthorized copying prohibited
*/
import { AzureOpenAI } from 'openai';
import { DefaultAzureCredential } from '@azure/identity';
import axios from 'axios';
import fs from 'fs/promises';
import path from 'path';
export class NascodeAI {
constructor() {
this.nascode_endpoint = process.env.NASCODER_AI_ENDPOINT;
this.nascode_api_key = process.env.NASCODER_AI_KEY;
this.nascode_client = null;
this.nascode_protection_active = true;
this.nascode_initializeClient();
}
async nascode_initializeClient() {
if (this.nascode_api_key) {
this.nascode_client = new AzureOpenAI({
endpoint: this.nascode_endpoint,
apiKey: this.nascode_api_key,
apiVersion: "2024-02-01"
});
} else {
// For development, use mock client
this.nascode_client = {
chat: {
completions: {
create: async (nascode_params) => ({
choices: [{ message: { content: "Mock response for development" } }]
})
}
}
};
}
}
async nascode_analyzeIntent(nascode_input) {
const nascode_prompt = `
Analyze this user request and determine the intent and complexity:
User Request: "${nascode_input}"
Respond with JSON only:
{
"intent": "code_generation|architecture_planning|figma_conversion|code_optimization|database_design|general_question",
"complexity": 1-10,
"requires_files": true/false,
"requires_packages": true/false,
"programming_language": "detected language or null",
"framework": "detected framework or null",
"summary": "brief summary of what user wants"
}`;
try {
if (this.nascode_client.chat) {
const nascode_response = await this.nascode_client.chat.completions.create({
model: 'gpt-35-turbo',
messages: [{ role: 'user', content: nascode_prompt }],
max_tokens: 200,
temperature: 0.1
});
return JSON.parse(nascode_response.choices[0].message.content);
}
} catch (nascode_error) {
console.log('Using fallback intent analysis');
}
// Fallback intent analysis
return this.nascode_fallbackIntentAnalysis(nascode_input);
}
nascode_fallbackIntentAnalysis(nascode_input) {
const nascode_lower = nascode_input.toLowerCase();
if (nascode_lower.includes('react') || nascode_lower.includes('component')) {
return {
intent: 'code_generation',
complexity: 6,
requires_files: true,
requires_packages: true,
programming_language: 'javascript',
framework: 'react',
summary: 'Create React component or application'
};
}
if (nascode_lower.includes('figma') || nascode_lower.includes('design')) {
return {
intent: 'figma_conversion',
complexity: 8,
requires_files: true,
requires_packages: true,
programming_language: 'javascript',
framework: 'react',
summary: 'Convert design to code'
};
}
if (nascode_lower.includes('database') || nascode_lower.includes('schema')) {
return {
intent: 'database_design',
complexity: 7,
requires_files: true,
requires_packages: false,
programming_language: 'sql',
framework: null,
summary: 'Design database schema'
};
}
return {
intent: 'general_question',
complexity: 5,
requires_files: false,
requires_packages: false,
programming_language: null,
framework: null,
summary: 'General development question'
};
}
async nascode_createActionPlan(nascode_intent) {
const nascode_actions = [];
const nascode_risks = [];
let nascode_requires_permissions = false;
switch (nascode_intent.intent) {
case 'code_generation':
if (nascode_intent.framework === 'react') {
nascode_actions.push({
type: 'create_directory',
description: `Create ${nascode_intent.framework} project directory`,
path: `./${nascode_intent.framework}-app`
});
nascode_actions.push({
type: 'install_packages',
description: 'Install required npm packages',
packages: ['react', 'react-dom', '@types/react']
});
nascode_actions.push({
type: 'generate_code',
description: 'Generate React components and files',
language: nascode_intent.programming_language
});
nascode_requires_permissions = true;
nascode_risks.push('Will create new directory and files');
nascode_risks.push('Will install npm packages');
}
break;
case 'figma_conversion':
nascode_actions.push({
type: 'analyze_figma',
description: 'Analyze Figma design',
});
nascode_actions.push({
type: 'generate_react_component',
description: 'Generate React component from design',
});
nascode_requires_permissions = true;
nascode_risks.push('Will create React component files');
break;
case 'database_design':
nascode_actions.push({
type: 'design_schema',
description: 'Design database schema',
});
nascode_actions.push({
type: 'create_sql_files',
description: 'Create SQL migration files',
});
nascode_requires_permissions = true;
nascode_risks.push('Will create SQL files');
break;
case 'architecture_planning':
nascode_actions.push({
type: 'plan_architecture',
description: 'Create comprehensive architecture plan',
});
nascode_actions.push({
type: 'generate_documentation',
description: 'Generate technical documentation',
});
nascode_requires_permissions = true;
nascode_risks.push('Will create documentation files');
break;
default:
nascode_actions.push({
type: 'answer_question',
description: 'Provide detailed answer',
});
}
return {
summary: nascode_intent.summary,
actions: nascode_actions,
risks: nascode_risks,
requiresPermissions: nascode_requires_permissions,
permissions: nascode_requires_permissions ? ['file_system', 'npm_install'] : []
};
}
async nascode_executeAction(nascode_action) {
try {
switch (nascode_action.type) {
case 'create_directory':
return await this.nascode_createDirectory(nascode_action);
case 'install_packages':
return await this.nascode_installPackages(nascode_action);
case 'generate_code':
return await this.nascode_generateCode(nascode_action);
case 'analyze_figma':
return await this.nascode_analyzeFigma(nascode_action);
case 'generate_react_component':
return await this.nascode_generateReactComponent(nascode_action);
case 'design_schema':
return await this.nascode_designSchema(nascode_action);
case 'create_sql_files':
return await this.nascode_createSqlFiles(nascode_action);
case 'plan_architecture':
return await this.nascode_planArchitecture(nascode_action);
case 'answer_question':
return await this.nascode_answerQuestion(nascode_action);
default:
return { success: false, error: 'Unknown action type' };
}
} catch (nascode_error) {
return { success: false, error: nascode_error.message };
}
}
async nascode_createDirectory(nascode_action) {
try {
await fs.mkdir(nascode_action.path, { recursive: true });
return { success: true, files: [nascode_action.path] };
} catch (nascode_error) {
return { success: false, error: nascode_error.message };
}
}
async nascode_installPackages(nascode_action) {
// For now, just simulate package installation
// In production, you'd use child_process to run npm install
return {
success: true,
message: `Would install: ${nascode_action.packages.join(', ')}`
};
}
async nascode_generateCode(nascode_action) {
const nascode_component_code = `
import React from 'react';
import './App.css';
interface AppProps {
title?: string;
}
const App: React.FC<AppProps> = ({ title = 'nascoder Generated App' }) => {
return (
<div className="app">
<header className="app-header">
<h1>{title}</h1>
<p>Generated by nascoder AI Assistant</p>
</header>
<main className="app-main">
<p>Your React application is ready!</p>
<button onClick={() => alert('Hello from nascoder!')}>
Click me
</button>
</main>
</div>
);
};
export default App;
`;
try {
await fs.writeFile('App.tsx', nascode_component_code);
return {
success: true,
code: nascode_component_code.substring(0, 300) + '...', // Show preview
files: ['App.tsx']
};
} catch (nascode_error) {
return { success: false, error: nascode_error.message };
}
}
async nascode_analyzeFigma(nascode_action) {
return {
success: true,
message: 'Figma analysis completed (demo mode)'
};
}
async nascode_generateReactComponent(nascode_action) {
const nascode_component_code = `
import React from 'react';
import './Component.css';
interface ComponentProps {
title: string;
description?: string;
}
const GeneratedComponent: React.FC<ComponentProps> = ({ title, description }) => {
return (
<div className="generated-component">
<h2>{title}</h2>
{description && <p>{description}</p>}
<div className="component-actions">
<button className="primary-btn">Primary Action</button>
<button className="secondary-btn">Secondary Action</button>
</div>
</div>
);
};
export default GeneratedComponent;
`;
try {
await fs.writeFile('GeneratedComponent.tsx', nascode_component_code);
return {
success: true,
code: nascode_component_code,
files: ['GeneratedComponent.tsx']
};
} catch (nascode_error) {
return { success: false, error: nascode_error.message };
}
}
async nascode_designSchema(nascode_action) {
return {
success: true,
message: 'Database schema designed (demo mode)'
};
}
async nascode_createSqlFiles(nascode_action) {
const nascode_sql_code = `
-- Generated database schema by nascoder
CREATE TABLE users (
id INT PRIMARY KEY IDENTITY(1,1),
username NVARCHAR(50) UNIQUE NOT NULL,
email NVARCHAR(100) UNIQUE NOT NULL,
created_at DATETIME2 DEFAULT GETDATE()
);
CREATE TABLE projects (
id INT PRIMARY KEY IDENTITY(1,1),
user_id INT FOREIGN KEY REFERENCES users(id),
name NVARCHAR(100) NOT NULL,
description NVARCHAR(MAX),
created_at DATETIME2 DEFAULT GETDATE()
);
-- Indexes for performance
CREATE INDEX IX_projects_user_id ON projects(user_id);
CREATE INDEX IX_users_email ON users(email);
`;
try {
await fs.writeFile('schema.sql', nascode_sql_code);
return {
success: true,
code: nascode_sql_code,
files: ['schema.sql']
};
} catch (nascode_error) {
return { success: false, error: nascode_error.message };
}
}
async nascode_planArchitecture(nascode_action) {
return {
success: true,
message: 'Architecture plan created (demo mode)'
};
}
async nascode_answerQuestion(nascode_action) {
return {
success: true,
message: 'Question answered (demo mode)'
};
}
}