@luckychen1993/pm-mcp 0.1.1

package/dist/typescript-semantic.js

@@ -0,0 +1,282 @@
+import ts from "typescript";
+const ANALYZER_ID = `typescript:compiler-api-ast@${ts.version}`;
+function scriptKind(rel) {
+    const ext = rel.toLowerCase().split(".").pop();
+    if (ext === "tsx")
+        return ts.ScriptKind.TSX;
+    if (ext === "jsx")
+        return ts.ScriptKind.JSX;
+    if (ext === "js" || ext === "mjs" || ext === "cjs")
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function stringValue(node) {
+    return node && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : null;
+}
+function bindingNames(name) {
+    if (ts.isIdentifier(name))
+        return [name.text];
+    return name.elements.flatMap((element) => ts.isOmittedExpression(element) ? [] : bindingNames(element.name));
+}
+function bindingIdentifiers(name) {
+    if (ts.isIdentifier(name))
+        return [name];
+    return name.elements.flatMap((element) => ts.isOmittedExpression(element) ? [] : bindingIdentifiers(element.name));
+}
+function inMemoryChecker(rel, source) {
+    const options = {
+        target: ts.ScriptTarget.Latest,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        allowJs: true,
+        checkJs: false,
+        noLib: true,
+        noResolve: true,
+    };
+    const normalize = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "");
+    const expected = normalize(rel);
+    const host = {
+        fileExists: (fileName) => normalize(fileName) === expected,
+        readFile: (fileName) => normalize(fileName) === expected ? source.text : undefined,
+        getSourceFile: (fileName) => normalize(fileName) === expected ? source : undefined,
+        getDefaultLibFileName: () => "lib.d.ts",
+        writeFile: () => undefined,
+        getCurrentDirectory: () => "",
+        getDirectories: () => [],
+        getCanonicalFileName: normalize,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n",
+    };
+    return ts.createProgram({ rootNames: [expected], options, host }).getTypeChecker();
+}
+function hasModifier(node, kind) {
+    return Boolean(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === kind));
+}
+function expressionRoot(expression) {
+    if (ts.isIdentifier(expression))
+        return expression;
+    if (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression))
+        return expressionRoot(expression.expression);
+    if (ts.isParenthesizedExpression(expression) || ts.isNonNullExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+        return expressionRoot(expression.expression);
+    }
+    return null;
+}
+function expressionPath(expression) {
+    if (ts.isIdentifier(expression))
+        return expression.text;
+    if (ts.isPropertyAccessExpression(expression)) {
+        const parent = expressionPath(expression.expression);
+        return parent ? `${parent}.${expression.name.text}` : expression.name.text;
+    }
+    return "";
+}
+function exportedDeclarationNames(node) {
+    if (ts.isVariableStatement(node))
+        return node.declarationList.declarations.flatMap((declaration) => bindingNames(declaration.name));
+    if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) && node.name) {
+        return ts.isIdentifier(node.name) || ts.isStringLiteral(node.name) ? [node.name.text] : [];
+    }
+    return [];
+}
+function diagnosticText(source, diagnostic) {
+    const position = source.getLineAndCharacterOfPosition(diagnostic.start);
+    return `${position.line + 1}:${position.character + 1} ${ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")}`;
+}
+/**
+ * Syntax-semantic extraction backed by the same parser TypeScript uses to compile TS/JS.
+ * Calls are conservative syntactic uses of imported bindings; execution and dynamic
+ * dispatch still require runtime evidence.
+ */
+export function analyzeTypeScriptSource(rel, content) {
+    const source = ts.createSourceFile(rel, content, ts.ScriptTarget.Latest, true, scriptKind(rel));
+    const checker = inMemoryChecker(rel, source);
+    const parseDiagnostics = source.parseDiagnostics ?? [];
+    const diagnostics = parseDiagnostics.map((diagnostic) => diagnosticText(source, diagnostic));
+    const references = [];
+    const exports = [];
+    const symbolBindings = new Map();
+    const lineOf = (node) => source.getLineAndCharacterOfPosition(node.getStart(source, false)).line + 1;
+    const addReference = (node, kind, specifier, confidence, forceLocal = false, symbol) => {
+        if (!specifier.trim())
+            return;
+        references.push({ kind, specifier: specifier.trim(), line: lineOf(node), parser: ANALYZER_ID, confidence, forceLocal, offset: node.getStart(source, false), symbol });
+    };
+    const addExport = (node, name, typeOnly, sourceSpecifier) => {
+        exports.push({ name, line: lineOf(node), isTypeOnly: typeOnly, sourceSpecifier, parser: ANALYZER_ID, confidence: 0.99 });
+    };
+    const storeBinding = (identifier, binding) => {
+        const symbol = checker.getSymbolAtLocation(identifier);
+        if (symbol)
+            symbolBindings.set(symbol, binding);
+    };
+    const registerImportClause = (clause, specifier) => {
+        if (!clause)
+            return;
+        if (clause.name)
+            storeBinding(clause.name, { specifier, namespace: false, typeOnly: clause.isTypeOnly, imported: "default" });
+        if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+            storeBinding(clause.namedBindings.name, { specifier, namespace: true, typeOnly: clause.isTypeOnly, imported: "*" });
+        }
+        else if (clause.namedBindings) {
+            for (const element of clause.namedBindings.elements) {
+                storeBinding(element.name, {
+                    specifier,
+                    namespace: false,
+                    typeOnly: clause.isTypeOnly || element.isTypeOnly,
+                    imported: element.propertyName?.text ?? element.name.text,
+                });
+            }
+        }
+    };
+    const registerRequireBinding = (name, specifier) => {
+        if (ts.isIdentifier(name)) {
+            storeBinding(name, { specifier, namespace: true, typeOnly: false, imported: "*" });
+            return;
+        }
+        if (!ts.isObjectBindingPattern(name))
+            return;
+        for (const element of name.elements) {
+            for (const identifier of bindingIdentifiers(element.name)) {
+                const local = identifier.text;
+                const imported = element.propertyName && (ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName))
+                    ? element.propertyName.text
+                    : local;
+                storeBinding(identifier, { specifier, namespace: false, typeOnly: false, imported });
+            }
+        }
+    };
+    const requireSpecifier = (expression) => {
+        if (!expression || !ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.expression.text !== "require")
+            return null;
+        return stringValue(expression.arguments[0]);
+    };
+    const collectDeclarations = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            const specifier = stringValue(node.moduleSpecifier);
+            if (specifier) {
+                addReference(node, "import", specifier, 0.99, specifier.startsWith("."));
+                registerImportClause(node.importClause, specifier);
+            }
+        }
+        else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+            const specifier = stringValue(node.moduleReference.expression);
+            if (specifier) {
+                addReference(node, "import", specifier, 0.98, specifier.startsWith("."));
+                storeBinding(node.name, { specifier, namespace: true, typeOnly: node.isTypeOnly, imported: "*" });
+            }
+        }
+        else if (ts.isVariableDeclaration(node)) {
+            const specifier = requireSpecifier(node.initializer);
+            if (specifier) {
+                addReference(node, "import", specifier, 0.98, specifier.startsWith("."));
+                registerRequireBinding(node.name, specifier);
+            }
+        }
+        else if (ts.isExportDeclaration(node)) {
+            const specifier = stringValue(node.moduleSpecifier);
+            if (specifier)
+                addReference(node, "export", specifier, 0.99, specifier.startsWith("."));
+            if (!node.exportClause) {
+                addExport(node, "*", node.isTypeOnly, specifier ?? undefined);
+            }
+            else if (ts.isNamespaceExport(node.exportClause)) {
+                addExport(node.exportClause, node.exportClause.name.text, node.isTypeOnly, specifier ?? undefined);
+            }
+            else {
+                for (const element of node.exportClause.elements)
+                    addExport(element, element.name.text, node.isTypeOnly || element.isTypeOnly, specifier ?? undefined);
+            }
+        }
+        else if (hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+            const names = exportedDeclarationNames(node);
+            const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+            if (isDefault)
+                addExport(node, "default", false);
+            else
+                for (const name of names)
+                    addExport(node, name, ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node));
+        }
+        else if (ts.isExportAssignment(node)) {
+            addExport(node, node.isExportEquals ? "export=" : "default", false);
+        }
+        ts.forEachChild(node, collectDeclarations);
+    };
+    collectDeclarations(source);
+    const collectUses = (node) => {
+        if (ts.isCallExpression(node)) {
+            if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+                const specifier = stringValue(node.arguments[0]);
+                if (specifier)
+                    addReference(node, "import", specifier, 0.98, specifier.startsWith("."));
+            }
+            else if (!(ts.isIdentifier(node.expression) && node.expression.text === "require")) {
+                const root = expressionRoot(node.expression);
+                const rootSymbol = root ? checker.getSymbolAtLocation(root) : undefined;
+                const binding = rootSymbol ? symbolBindings.get(rootSymbol) : undefined;
+                if (binding && !binding.typeOnly)
+                    addReference(node, "call", binding.specifier, 0.94, binding.specifier.startsWith("."), binding.imported);
+                const callee = expressionPath(node.expression);
+                const firstArgument = stringValue(node.arguments[0]);
+                if (firstArgument && (/^(?:fetch|axios\.(?:get|post|put|patch|delete)|http\.(?:get|post))$/i.test(callee))) {
+                    addReference(node, "http", firstArgument, 0.96);
+                }
+                if (firstArgument && /^(?:grpc\.(?:dial|insecure_channel|secure_channel)|grpcchannel\.foraddress)$/i.test(callee)) {
+                    addReference(node, "grpc", firstArgument, 0.94);
+                }
+                if (firstArgument && /^(?:ffi\.library|dlopen)$/i.test(callee))
+                    addReference(node, "ffi", firstArgument, 0.94);
+            }
+        }
+        else if (ts.isNewExpression(node)) {
+            const root = expressionRoot(node.expression);
+            const rootSymbol = root ? checker.getSymbolAtLocation(root) : undefined;
+            const binding = rootSymbol ? symbolBindings.get(rootSymbol) : undefined;
+            if (binding && !binding.typeOnly)
+                addReference(node, "call", binding.specifier, 0.94, binding.specifier.startsWith("."), binding.imported);
+            const firstArgument = stringValue(node.arguments?.[0]);
+            if (firstArgument && /(?:Client|Stub)$/.test(expressionPath(node.expression)))
+                addReference(node, "grpc", firstArgument, 0.86);
+        }
+        else if (ts.isStringLiteralLike(node)) {
+            const value = node.text;
+            const pathPart = value.split("#", 1)[0].replace(/\\/g, "/");
+            const basename = pathPart.split("/").at(-1) ?? "";
+            // Extension constants such as ".proto" are metadata, not contract links.
+            // Requiring a real basename keeps AST evidence precise while still
+            // accepting both nearby files (service.proto) and relative paths.
+            if (/^[^.\s][^/\s]*\.(?:proto|graphql|gql)$/i.test(basename))
+                addReference(node, "contract", value, 0.98, true);
+            else if (/^[^.\s][^/\s]*(?:openapi|swagger|asyncapi|contracts?|schemas?)[^/\s]*\.(?:ya?ml|json)$/i.test(basename))
+                addReference(node, "contract", value, 0.95, true);
+        }
+        else if (ts.isTaggedTemplateExpression(node) && /^(?:gql|graphql)$/.test(expressionPath(node.tag))) {
+            addReference(node, "contract", "inline GraphQL", 0.96);
+        }
+        ts.forEachChild(node, collectUses);
+    };
+    collectUses(source);
+    const uniqueReferences = [...new Map(references.map((reference) => [
+            `${reference.kind}|${reference.line}|${reference.specifier}|${reference.offset ?? ""}`,
+            reference,
+        ])).values()];
+    const uniqueExports = [...new Map(exports.map((item) => [`${item.name}|${item.line}|${item.sourceSpecifier ?? ""}`, item])).values()];
+    return {
+        references: uniqueReferences,
+        exports: uniqueExports,
+        analyzer: {
+            id: ANALYZER_ID,
+            family: "compiler-ast",
+            assurance: "ast",
+            engine: "TypeScript Compiler API",
+            version: ts.version,
+            capabilities: ["imports", "exports", "calls", "contracts", "http", "grpc", "ffi"],
+        },
+        status: diagnostics.length === 0 ? "complete" : "partial",
+        diagnostics,
+        limitations: [
+            "AST call edges prove syntactic use of an imported binding, not runtime execution.",
+            "Generated code, reflection, dependency-injection containers, and data-driven dispatch require imported native or runtime evidence.",
+        ],
+    };
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@luckychen1993/pm-mcp",
+  "version": "0.1.1",
+  "description": "AI 编码项目的单一事实来源 + 健康台账 MCP 服务（事实来源 / 路线图 / 防幻觉 / 七本账 / 断点续做 / token 经济）",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-coding",
+    "project-management",
+    "code-governance"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/happy520ai/pm-mcp.git"
+  },
+  "homepage": "https://github.com/happy520ai/pm-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/happy520ai/pm-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "pm-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.scripts.json",
+    "test": "node --test \"test/*.test.ts\"",
+    "coverage": "node --experimental-test-coverage --test-coverage-include=\"src/**/*.ts\" --test-coverage-lines=90 --test-coverage-branches=85 --test-coverage-functions=90 --test \"test/*.test.ts\"",
+    "audit": "node scripts/health-check.mts",
+    "benchmark": "node scripts/benchmark.mts",
+    "benchmark:volume": "node scripts/benchmark-volume.mts",
+    "quality": "node scripts/quality-gate.mts",
+    "quality:plan": "node scripts/quality-gate.mts --plan",
+    "acceptance:evidence": "node scripts/collect-acceptance-evidence.mts --root .",
+    "acceptance:prepare": "node scripts/create-pm-acceptance-evaluation.mts --root .",
+    "acceptance": "node scripts/acceptance-gate.mts --root . --baseline-id pm-mcp-local-release --baseline-version 1.0.0 --evaluation .pm/acceptance/evaluations/pm-mcp-local-release-1.0.0.json",
+    "acceptance:cycle": "node scripts/acceptance-cycle.mts --root .",
+    "gate": "npm run audit -- --root . && npm run quality && npm run acceptance:cycle",
+    "start": "node dist/index.js",
+    "dev": "node src/index.ts",
+    "inspect": "node dist/index.js"
+  },
+  "dependencies": {
+    "@ast-grep/lang-csharp": "0.0.6",
+    "@ast-grep/lang-go": "0.0.6",
+    "@ast-grep/lang-java": "0.0.7",
+    "@ast-grep/lang-kotlin": "0.0.7",
+    "@ast-grep/lang-python": "0.0.6",
+    "@ast-grep/lang-rust": "0.0.7",
+    "@ast-grep/napi": "0.45.3",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "typescript": "^5.9.3",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0"
+  }
+}