@mrfentmen/ini-mcp 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,34 @@
-# Temporary Holding Version
+# INI Files
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Parse, validate, convert and generate INI configuration offline - sections, comments and quoted values, keyless.
+
+Keyless — no signup, no API key, no environment variables.
+
+## Install
+
+```bash
+npx -y @mrfentmen/ini-mcp
+```
+
+Or add it to your MCP client:
+
+```json
+{
+  "mcpServers": {
+    "ini-mcp": { "command": "npx", "args": ["-y", "@mrfentmen/ini-mcp"] }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `parse_ini` | Parse INI text into sections and keys, with inline comments handled and problems reported. |
+| `ini_to_json` | Convert INI text into a JSON object keyed by section. |
+| `create_ini` | Build INI text from a JSON object: scalars go at the top, nested objects become sections. |
+| `validate_ini` | Check INI text for structural problems: bad lines, unterminated quotes, duplicate sections and keys. |
+
+## Data source
+
+Runs fully offline — all work happens inside the server with no API calls and no keys.

package/dist/api.d.ts

@@ -0,0 +1,19 @@
+/**
+ * INI Files — keyless public API client.
+ */
+export declare class SourceError extends Error {
+}
+export declare function section(title: string, rows: string[]): string;
+export declare function parseIniFile(a: {
+    text: string;
+}): Promise<string>;
+export declare function iniToJson(a: {
+    text: string;
+    mergeDuplicateSections?: boolean;
+}): Promise<string>;
+export declare function createIni(a: {
+    json: string;
+}): Promise<string>;
+export declare function validateIni(a: {
+    text: string;
+}): Promise<string>;

package/dist/api.js

@@ -0,0 +1,205 @@
+/**
+ * INI Files — keyless public API client.
+ */
+export class SourceError extends Error {
+}
+export function section(title, rows) {
+    return [title, ...rows.filter(Boolean)].join("\n");
+}
+function stripInlineComment(value) {
+    let inQuote = null;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (inQuote) {
+            if (ch === inQuote)
+                inQuote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inQuote = ch;
+            continue;
+        }
+        if ((ch === ";" || ch === "#") && (i === 0 || /\s/.test(value[i - 1]))) {
+            return value.slice(0, i).trimEnd();
+        }
+    }
+    return value.trimEnd();
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'")))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseIni(text) {
+    const entries = [];
+    const errors = [];
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    lines.forEach((raw, index) => {
+        const lineNo = index + 1;
+        const line = raw.trim();
+        if (!line)
+            return;
+        if (line.startsWith(";") || line.startsWith("#")) {
+            entries.push({ kind: "comment", text: line });
+            return;
+        }
+        if (line.startsWith("[")) {
+            if (!line.endsWith("]")) {
+                errors.push(`line ${lineNo}: section header is missing its closing bracket`);
+                return;
+            }
+            const name = line.slice(1, -1).trim();
+            if (!name)
+                errors.push(`line ${lineNo}: section name is empty`);
+            entries.push({ kind: "section", name });
+            return;
+        }
+        const eq = line.indexOf("=");
+        if (eq < 0) {
+            const colon = line.indexOf(":");
+            if (colon > 0) {
+                const key = line.slice(0, colon).trim();
+                const value = stripInlineComment(line.slice(colon + 1));
+                entries.push({ kind: "pair", key, value: unquote(value) });
+                return;
+            }
+            errors.push(`line ${lineNo}: not a key=value pair: "${line.slice(0, 40)}"`);
+            return;
+        }
+        const key = line.slice(0, eq).trim();
+        if (!key) {
+            errors.push(`line ${lineNo}: the key before "=" is empty`);
+            return;
+        }
+        const value = stripInlineComment(line.slice(eq + 1));
+        if (unquote(value).length === 0 && value.trim() !== "" && !/^["']{2}$/.test(value.trim())) {
+            errors.push(`line ${lineNo}: the value has an unterminated quote`);
+        }
+        entries.push({ kind: "pair", key, value: unquote(value) });
+    });
+    return { entries, errors };
+}
+function group(entries) {
+    const sections = [];
+    let current = { name: "", pairs: [] };
+    sections.push(current);
+    for (const entry of entries) {
+        if (entry.kind === "section") {
+            current = { name: entry.name, pairs: [] };
+            sections.push(current);
+        }
+        else if (entry.kind === "pair") {
+            current.pairs.push({ key: entry.key, value: entry.value });
+        }
+    }
+    return sections.filter((s) => s.name || s.pairs.length);
+}
+export async function parseIniFile(a) {
+    const { entries, errors } = parseIni(a.text);
+    const sections = group(entries);
+    if (!entries.length)
+        throw new SourceError("no ini content found");
+    const lines = [];
+    for (const section of sections) {
+        lines.push(section.name ? `[${section.name}]` : "(top level, no section)");
+        for (const pair of section.pairs)
+            lines.push(`  ${pair.key} = ${pair.value}`);
+        lines.push("");
+    }
+    return [
+        `${sections.length} section(s), ${entries.filter((e) => e.kind === "pair").length} key(s):`,
+        "",
+        ...lines,
+        ...(errors.length ? ["Problems:", ...errors.map((e) => `- ${e}`)] : []),
+    ].join("\n").trimEnd();
+}
+export async function iniToJson(a) {
+    const { entries, errors } = parseIni(a.text);
+    if (errors.length)
+        throw new SourceError(`the ini text has problems: ${errors.join("; ")}`);
+    const sections = group(entries);
+    const out = {};
+    for (const section of sections) {
+        const name = section.name || "default";
+        for (const pair of section.pairs) {
+            out[name] = out[name] ?? {};
+            if (pair.key in out[name] && !a.mergeDuplicateSections) {
+                throw new SourceError(`key "${pair.key}" appears twice in section "${name}"`);
+            }
+            out[name][pair.key] = pair.value;
+        }
+    }
+    return [
+        "Parsed ini as JSON:",
+        "",
+        JSON.stringify(out, null, 2),
+    ].join("\n");
+}
+export async function createIni(a) {
+    let data;
+    try {
+        data = JSON.parse(a.json);
+    }
+    catch (e) {
+        throw new SourceError(`json is not valid: ${e.message}`);
+    }
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+        throw new SourceError("json must be an object of key/value pairs and nested objects");
+    }
+    const scalars = (value) => value === null || ["string", "number", "boolean"].includes(typeof value);
+    const lines = [];
+    const render = (value) => (value === null ? "" : String(value));
+    for (const [key, value] of Object.entries(data)) {
+        if (scalars(value))
+            lines.push(`${key} = ${render(value)}`);
+    }
+    for (const [section, value] of Object.entries(data)) {
+        if (scalars(value))
+            continue;
+        if (Array.isArray(value)) {
+            lines.push("", `[${section}]`, `values = ${value.map(render).join(",")}`);
+            continue;
+        }
+        if (value !== null && typeof value === "object") {
+            lines.push("", `[${section}]`);
+            for (const [key, inner] of Object.entries(value)) {
+                if (inner !== null && typeof inner === "object")
+                    throw new SourceError(`section "${section}" key "${key}" nests too deeply for an ini file`);
+                lines.push(`${key} = ${render(inner)}`);
+            }
+        }
+    }
+    if (!lines.length)
+        throw new SourceError("json has no values to write");
+    return [`Generated ini (${lines.length} line(s)):`, "", lines.join("\n")].join("\n");
+}
+export async function validateIni(a) {
+    const { entries, errors } = parseIni(a.text);
+    const problems = [...errors];
+    const seenSections = new Set();
+    let current = "";
+    const seenKeys = new Set();
+    for (const entry of entries) {
+        if (entry.kind === "section") {
+            if (seenSections.has(entry.name))
+                problems.push(`section [${entry.name}] is defined more than once`);
+            seenSections.add(entry.name);
+            current = entry.name;
+            seenKeys.clear();
+        }
+        else if (entry.kind === "pair") {
+            const id = `${current}\u0000${entry.key}`;
+            if (seenKeys.has(entry.key))
+                problems.push(`key "${entry.key}" appears twice${current ? ` in [${current}]` : " at the top level"}`);
+            seenKeys.add(entry.key);
+            void id;
+        }
+    }
+    return [
+        problems.length ? `Invalid ini — ${problems.length} problem(s):` : "Valid ini.",
+        "",
+        ...problems.map((p) => `- ${p}`),
+    ].join("\n").trimEnd();
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("ini-mcp running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,53 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { createIni, iniToJson, parseIniFile, validateIni, SourceError } from "./api.js";
+const text = (t) => ({ content: [{ type: "text", text: t }] });
+function errorMessage(e) {
+    if (e instanceof SourceError || e instanceof Error)
+        return `Error: ${e.message}`;
+    return `Error: ${String(e)}`;
+}
+export function createServer() {
+    const server = new McpServer({ name: "ini-mcp", version: "1.0.0" });
+    server.tool("parse_ini", "Parse INI text into sections and keys, with inline comments handled and problems reported.", {
+        text: z.string().describe('INI text')
+    }, async (a) => {
+        try {
+            return text(await parseIniFile(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    server.tool("ini_to_json", "Convert INI text into a JSON object keyed by section.", {
+        text: z.string().describe('INI text'), mergeDuplicateSections: z.boolean().optional().describe('Allow a section to appear more than once')
+    }, async (a) => {
+        try {
+            return text(await iniToJson(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    server.tool("create_ini", "Build INI text from a JSON object: scalars go at the top, nested objects become sections.", {
+        json: z.string().describe('JSON object to turn into INI')
+    }, async (a) => {
+        try {
+            return text(await createIni(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    server.tool("validate_ini", "Check INI text for structural problems: bad lines, unterminated quotes, duplicate sections and keys.", {
+        text: z.string().describe('INI text')
+    }, async (a) => {
+        try {
+            return text(await validateIni(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    return server;
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@mrfentmen/ini-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Parse, validate, convert and generate INI configuration offline - sections, comments and quoted values, keyless.",
+  "type": "module",
+  "mcpName": "io.github.mrfentmen/ini-mcp",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrfentmen/awesome-servers.git"
+  },
+  "bin": {
+    "ini-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "ini",
+    "config",
+    "parser",
+    "settings",
+    "offline",
+    "keyless"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}