latitude-mcp-server 1.0.0

package/package.json

@@ -0,0 +1,118 @@
+{
+	"name": "latitude-mcp-server",
+	"version": "1.0.0",
+	"description": "MCP server for Latitude prompt management - manage prompts, versions, and run AI conversations",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"type": "commonjs",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/yigitkonur/latitude-mcp-server.git"
+	},
+	"bin": {
+		"latitude-mcp": "./dist/index.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"prepare": "npm run build && node scripts/ensure-executable.js",
+		"postinstall": "node scripts/ensure-executable.js",
+		"clean": "rm -rf dist coverage",
+		"test": "jest",
+		"test:coverage": "jest --coverage",
+		"lint": "eslint src --ext .ts --config eslint.config.mjs",
+		"update:deps": "npx npm-check-updates -u && npm install --legacy-peer-deps",
+		"format": "prettier --write 'src/**/*.ts' 'scripts/**/*.js'",
+		"cli": "npm run build && node dist/index.js",
+		"mcp:stdio": "npm run build && TRANSPORT_MODE=stdio node dist/index.js",
+		"mcp:http": "npm run build && TRANSPORT_MODE=http node dist/index.js",
+		"mcp:inspect": "npm run build && (TRANSPORT_MODE=http node dist/index.js &) && sleep 2 && npx @modelcontextprotocol/inspector http://localhost:3000/mcp",
+		"dev:stdio": "npm run build && npx @modelcontextprotocol/inspector -e TRANSPORT_MODE=stdio -e DEBUG=true node dist/index.js",
+		"dev:http": "npm run build && DEBUG=true TRANSPORT_MODE=http node dist/index.js"
+	},
+	"keywords": [
+		"mcp",
+		"model-context-protocol",
+		"latitude",
+		"prompt-management",
+		"ai",
+		"llm",
+		"typescript",
+		"claude",
+		"anthropic",
+		"prompts",
+		"version-control",
+		"mcp-server"
+	],
+	"author": "Andi Ashari",
+	"license": "ISC",
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"devDependencies": {
+		"@eslint/js": "^9.39.1",
+		"@semantic-release/changelog": "^6.0.3",
+		"@semantic-release/exec": "^7.1.0",
+		"@semantic-release/git": "^10.0.1",
+		"@semantic-release/github": "^12.0.2",
+		"@semantic-release/npm": "^13.1.2",
+		"@types/cors": "^2.8.19",
+		"@types/express": "^5.0.5",
+		"@types/jest": "^30.0.0",
+		"@types/jmespath": "^0.15.2",
+		"@types/node": "^24.10.1",
+		"@typescript-eslint/eslint-plugin": "^8.48.0",
+		"@typescript-eslint/parser": "^8.48.0",
+		"eslint": "^9.39.1",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-prettier": "^5.5.4",
+		"jest": "^30.2.0",
+		"prettier": "^3.7.3",
+		"semantic-release": "^25.0.2",
+		"ts-jest": "^29.4.5",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.48.0"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.23.0",
+		"@toon-format/toon": "^2.0.1",
+		"commander": "^14.0.2",
+		"cors": "^2.8.5",
+		"dotenv": "^17.2.3",
+		"express": "^5.1.0",
+		"jmespath": "^0.16.0",
+		"zod": "^4.1.13"
+	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org/",
+		"access": "public"
+	},
+	"jest": {
+		"preset": "ts-jest",
+		"testEnvironment": "node",
+		"setupFilesAfterEnv": [
+			"<rootDir>/src/utils/jest.setup.ts"
+		],
+		"testMatch": [
+			"**/src/**/*.test.ts"
+		],
+		"collectCoverageFrom": [
+			"src/**/*.ts",
+			"!src/**/*.test.ts",
+			"!src/utils/jest.setup.ts"
+		],
+		"transform": {
+			"^.+\\.tsx?$": [
+				"ts-jest",
+				{
+					"useESM": true
+				}
+			]
+		},
+		"moduleNameMapper": {
+			"(.*)\\.(js|jsx)$": "$1"
+		},
+		"extensionsToTreatAsEsm": [
+			".ts"
+		]
+	}
+}

package/scripts/ensure-executable.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Use dynamic import meta for ESM compatibility
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+const entryPoint = path.join(rootDir, 'dist', 'index.js');
+
+try {
+	if (fs.existsSync(entryPoint)) {
+		// Ensure the file is executable (cross-platform)
+		const currentMode = fs.statSync(entryPoint).mode;
+		// Check if executable bits are set (user, group, or other)
+		// Mode constants differ slightly across platforms, checking broadly
+		const isExecutable =
+			currentMode & fs.constants.S_IXUSR ||
+			currentMode & fs.constants.S_IXGRP ||
+			currentMode & fs.constants.S_IXOTH;
+
+		if (!isExecutable) {
+			// Set permissions to 755 (rwxr-xr-x) if not executable
+			fs.chmodSync(entryPoint, 0o755);
+			console.log(
+				`Made ${path.relative(rootDir, entryPoint)} executable`,
+			);
+		} else {
+			// console.log(`${path.relative(rootDir, entryPoint)} is already executable`);
+		}
+	} else {
+		// console.warn(`${path.relative(rootDir, entryPoint)} not found, skipping chmod`);
+	}
+} catch (err) {
+	// console.warn(`Failed to set executable permissions: ${err.message}`);
+	// We use '|| true' in package.json, so no need to exit here
+}

package/scripts/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+} 

package/scripts/update-version.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+/**
+ * Script to update version numbers across the project
+ * Usage: node scripts/update-version.js [version] [options]
+ * Options:
+ *   --dry-run   Show what changes would be made without applying them
+ *   --verbose   Show detailed logging information
+ *
+ * If no version is provided, it will use the version from package.json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get the directory name of the current module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const options = {
+	dryRun: args.includes('--dry-run'),
+	verbose: args.includes('--verbose'),
+};
+
+// Get the version (first non-flag argument)
+let newVersion = args.find((arg) => !arg.startsWith('--'));
+
+// Log helper function
+const log = (message, verbose = false) => {
+	if (!verbose || options.verbose) {
+		console.log(message);
+	}
+};
+
+// File paths that may contain version information
+const versionFiles = [
+	{
+		path: path.join(rootDir, 'package.json'),
+		pattern: /"version": "([^"]*)"/,
+		replacement: (match, currentVersion) =>
+			match.replace(currentVersion, newVersion),
+	},
+	{
+		path: path.join(rootDir, 'src', 'utils', 'constants.util.ts'),
+		pattern: /export const VERSION = ['"]([^'"]*)['"]/,
+		replacement: (match, currentVersion) =>
+			match.replace(currentVersion, newVersion),
+	},
+	// Also update the compiled JavaScript files if they exist
+	{
+		path: path.join(rootDir, 'dist', 'utils', 'constants.util.js'),
+		pattern: /exports.VERSION = ['"]([^'"]*)['"]/,
+		replacement: (match, currentVersion) =>
+			match.replace(currentVersion, newVersion),
+		optional: true, // Mark this file as optional
+	},
+	// Additional files can be added here with their patterns and replacement logic
+];
+
+/**
+ * Read the version from package.json
+ * @returns {string} The version from package.json
+ */
+function getPackageVersion() {
+	try {
+		const packageJsonPath = path.join(rootDir, 'package.json');
+		log(`Reading version from ${packageJsonPath}`, true);
+
+		const packageJson = JSON.parse(
+			fs.readFileSync(packageJsonPath, 'utf8'),
+		);
+
+		if (!packageJson.version) {
+			throw new Error('No version field found in package.json');
+		}
+
+		return packageJson.version;
+	} catch (error) {
+		console.error(`Error reading package.json: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+/**
+ * Validate the semantic version format
+ * @param {string} version - The version to validate
+ * @returns {boolean} True if valid, throws error if invalid
+ */
+function validateVersion(version) {
+	// More comprehensive semver regex
+	const semverRegex =
+		/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+	if (!semverRegex.test(version)) {
+		throw new Error(
+			`Invalid version format: ${version}\nPlease use semantic versioning format (e.g., 1.2.3, 1.2.3-beta.1, etc.)`,
+		);
+	}
+
+	return true;
+}
+
+/**
+ * Update version in a specific file
+ * @param {Object} fileConfig - Configuration for the file to update
+ */
+function updateFileVersion(fileConfig) {
+	const {
+		path: filePath,
+		pattern,
+		replacement,
+		optional = false,
+	} = fileConfig;
+
+	try {
+		log(`Checking ${filePath}...`, true);
+
+		if (!fs.existsSync(filePath)) {
+			if (optional) {
+				log(`Optional file not found (skipping): ${filePath}`, true);
+				return;
+			}
+			console.warn(`Warning: File not found: ${filePath}`);
+			return;
+		}
+
+		// Read file content
+		const fileContent = fs.readFileSync(filePath, 'utf8');
+		const match = fileContent.match(pattern);
+
+		if (!match) {
+			console.warn(`Warning: Version pattern not found in ${filePath}`);
+			return;
+		}
+
+		const currentVersion = match[1];
+		if (currentVersion === newVersion) {
+			log(
+				`Version in ${path.basename(filePath)} is already ${newVersion}`,
+				true,
+			);
+			return;
+		}
+
+		// Create new content with the updated version
+		const updatedContent = fileContent.replace(pattern, replacement);
+
+		// Write the changes or log them in dry run mode
+		if (options.dryRun) {
+			log(
+				`Would update version in ${filePath} from ${currentVersion} to ${newVersion}`,
+			);
+		} else {
+			// Create a backup of the original file
+			fs.writeFileSync(`${filePath}.bak`, fileContent);
+			log(`Backup created: ${filePath}.bak`, true);
+
+			// Write the updated content
+			fs.writeFileSync(filePath, updatedContent);
+			log(
+				`Updated version in ${path.basename(filePath)} from ${currentVersion} to ${newVersion}`,
+			);
+		}
+	} catch (error) {
+		if (optional) {
+			log(`Error with optional file ${filePath}: ${error.message}`, true);
+			return;
+		}
+		console.error(`Error updating ${filePath}: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+// Main execution
+try {
+	// If no version specified, get from package.json
+	if (!newVersion) {
+		newVersion = getPackageVersion();
+		log(
+			`No version specified, using version from package.json: ${newVersion}`,
+		);
+	}
+
+	// Validate the version format
+	validateVersion(newVersion);
+
+	// Update all configured files
+	for (const fileConfig of versionFiles) {
+		updateFileVersion(fileConfig);
+	}
+
+	if (options.dryRun) {
+		log(`\nDry run completed. No files were modified.`);
+	} else {
+		log(`\nVersion successfully updated to ${newVersion}`);
+	}
+} catch (error) {
+	console.error(`\nVersion update failed: ${error.message}`);
+	process.exit(1);
+}