import { z } from "zod";
// Continue.dev config generator
export const generateContinueConfigSchema = {
name: "generate_continue_config",
description: "Generates a .continue/config.json file for Continue.dev.",
inputSchema: z.object({
projectName: z.string(),
languages: z.array(z.string()),
model: z
.string()
.optional()
.describe("AI model to use (e.g., gpt-4, claude-3)"),
}),
};
export function generateContinueConfigHandler(args: any) {
const { projectName, languages, model = "gpt-4" } = args;
const content = JSON.stringify(
{
title: projectName,
models: [
{
title: model,
provider: "openai",
model: model,
},
],
customCommands: [
{
name: "test",
prompt: "Write tests for the selected code",
},
{
name: "explain",
prompt: "Explain this code in detail",
},
],
contextProviders: [{ name: "codebase" }, { name: "files" }],
systemMessage: `You are helping with a ${languages.join("/")} project called ${projectName}. Follow best practices and write clean, tested code.`,
},
null,
2,
);
return { content: [{ type: "text", text: content }] };
}
// Tabnine config generator
export const generateTabnineConfigSchema = {
name: "generate_tabnine_config",
description: "Generates a .tabnine.json configuration file.",
inputSchema: z.object({
projectName: z.string(),
languages: z.array(z.string()),
}),
};
export function generateTabnineConfigHandler(args: any) {
const { projectName, languages } = args;
const content = JSON.stringify(
{
version: "1.0.0",
project_name: projectName,
enabled: true,
languages: languages.reduce((acc: any, lang: string) => {
acc[lang] = { enabled: true };
return acc;
}, {}),
completion: {
inline: true,
full_line: true,
},
},
null,
2,
);
return { content: [{ type: "text", text: content }] };
}
// VSCode tasks.json generator
export const generateVSCodeTasksSchema = {
name: "generate_vscode_tasks",
description: "Generates a .vscode/tasks.json file for VSCode.",
inputSchema: z.object({
projectName: z.string(),
language: z.string(),
buildCommand: z.string().optional(),
testCommand: z.string().optional(),
}),
};
export function generateVSCodeTasksHandler(args: any) {
const { projectName, language, buildCommand, testCommand } = args;
const defaultBuild =
language === "typescript"
? "npm run build"
: language === "python"
? "python -m pytest"
: language === "rust"
? "cargo build"
: "npm run build";
const defaultTest =
language === "typescript"
? "npm test"
: language === "python"
? "python -m pytest"
: language === "rust"
? "cargo test"
: "npm test";
const content = JSON.stringify(
{
version: "2.0.0",
tasks: [
{
label: "Build",
type: "shell",
command: buildCommand || defaultBuild,
group: { kind: "build", isDefault: true },
problemMatcher: ["$tsc"],
},
{
label: "Test",
type: "shell",
command: testCommand || defaultTest,
group: { kind: "test", isDefault: true },
},
],
},
null,
2,
);
return { content: [{ type: "text", text: content }] };
}
// VSCode launch.json generator
export const generateVSCodeLaunchSchema = {
name: "generate_vscode_launch",
description: "Generates a .vscode/launch.json file for debugging.",
inputSchema: z.object({
projectName: z.string(),
language: z.string(),
entryPoint: z.string().optional(),
}),
};
export function generateVSCodeLaunchHandler(args: any) {
const { projectName, language, entryPoint } = args;
let config: any;
if (language === "typescript" || language === "javascript") {
config = {
version: "0.2.0",
configurations: [
{
type: "node",
request: "launch",
name: `Launch ${projectName}`,
program: entryPoint || "${workspaceFolder}/dist/index.js",
preLaunchTask: "Build",
outFiles: ["${workspaceFolder}/dist/**/*.js"],
},
],
};
} else if (language === "python") {
config = {
version: "0.2.0",
configurations: [
{
name: `Python: ${projectName}`,
type: "python",
request: "launch",
program: entryPoint || "${workspaceFolder}/main.py",
console: "integratedTerminal",
},
],
};
} else {
config = {
version: "0.2.0",
configurations: [
{
name: `Launch ${projectName}`,
type: "node",
request: "launch",
program: entryPoint || "${workspaceFolder}/index.js",
},
],
};
}
return { content: [{ type: "text", text: JSON.stringify(config, null, 2) }] };
}
// JetBrains run config generator
export const generateJetBrainsConfigSchema = {
name: "generate_jetbrains_config",
description:
"Generates a .idea/runConfigurations XML file for JetBrains IDEs.",
inputSchema: z.object({
projectName: z.string(),
language: z.string(),
entryPoint: z.string().optional(),
}),
};
export function generateJetBrainsConfigHandler(args: any) {
const { projectName, language, entryPoint } = args;
let content: string;
if (language === "python") {
content = `<component name="ProjectRunConfigurationManager">
<configuration default="false" name="${projectName}" type="PythonConfigurationType">
<module name="${projectName}" />
<option name="SCRIPT_NAME" value="${entryPoint || "main.py"}" />
<option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
</configuration>
</component>`;
} else if (language === "javascript" || language === "typescript") {
content = `<component name="ProjectRunConfigurationManager">
<configuration default="false" name="${projectName}" type="NodeJSConfigurationType">
<option name="workingDir" value="$PROJECT_DIR$" />
<option name="pathToJsFile" value="${entryPoint || "dist/index.js"}" />
</configuration>
</component>`;
} else {
content = `<!-- Generic run configuration for ${projectName} -->
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="${projectName}" type="Application">
<option name="MAIN_CLASS_NAME" value="${entryPoint || "Main"}" />
</configuration>
</component>`;
}
return { content: [{ type: "text", text: content }] };
}