codegraph-java 0.1.0

package/dist/mcp/version.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Resolved package version, computed once at module load.
+ *
+ * The version string is the rendezvous datum between cooperating daemon and
+ * proxy processes: the daemon advertises its version in the hello line, and
+ * the proxy refuses to share IPC across a mismatch (falls back to direct
+ * mode). Keeping the resolution in one place avoids drift between the CLI
+ * `--version` output (which reads `package.json` directly) and the daemon
+ * handshake.
+ *
+ * Resolution strategy: read the bundled `package.json` two levels up from
+ * this file — same relative position whether we're loaded from `src/mcp/` or
+ * the `dist/mcp/` output, since `tsc` preserves the layout. If reading fails
+ * (e.g. the package was unpacked oddly), fall back to "0.0.0-unknown" — a
+ * sentinel that will never match a real version, so the proxy harmlessly
+ * falls back to direct mode.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGraphPackageVersion = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function readPackageVersion() {
+    try {
+        const pkgPath = path.join(__dirname, '..', '..', 'package.json');
+        const raw = fs.readFileSync(pkgPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.version === 'string' && parsed.version.length > 0) {
+            return parsed.version;
+        }
+    }
+    catch {
+        // Fall through to sentinel.
+    }
+    return '0.0.0-unknown';
+}
+exports.CodeGraphPackageVersion = readPackageVersion();
+//# sourceMappingURL=version.js.map

package/dist/mcp/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/mcp/version.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAyB;AACzB,2CAA6B;AAE7B,SAAS,kBAAkB;IACzB,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QACjE,MAAM,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,OAAO,MAAM,EAAE,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrE,OAAO,MAAM,CAAC,OAAO,CAAC;QACxB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,4BAA4B;IAC9B,CAAC;IACD,OAAO,eAAe,CAAC;AACzB,CAAC;AAEY,QAAA,uBAAuB,GAAG,kBAAkB,EAAE,CAAC"}

package/dist/project-config.d.ts

@@ -0,0 +1,158 @@
+import { Language } from './types';
+/** Filename of the project-scoped config. */
+export declare const PROJECT_CONFIG_FILENAME = "codegraph.json";
+/**
+ * Resolve the project config file path for a root.
+ *
+ * Product layout: the config lives INSIDE the per-project data directory
+ * (`.codegraph/codegraph.json`), co-located with `codegraph.db` — one directory
+ * holds the whole per-project state and can be moved/copied as a unit. A
+ * legacy config at the project root (pre-data-dir layout) is still honored for
+ * reading until the user moves it; NEW writes always go to the data dir.
+ */
+export declare function projectConfigFile(rootDir: string): string;
+export interface ProjectConfig {
+    /** Map of custom file extension (`.foo`) to a supported language id. */
+    extensions?: Record<string, string>;
+    /**
+     * Gitignore-style patterns naming gitignored directories whose embedded git
+     * repositories should be indexed anyway — the explicit opt-in to override
+     * `.gitignore` for nested-repo discovery (#622, #699). Absent/empty (the
+     * default) means `.gitignore` is fully respected: gitignored embedded repos
+     * are never discovered or indexed (#970, #976).
+     */
+    includeIgnored?: string[];
+    /**
+     * Gitignore-style patterns for paths to keep OUT of the index — even when
+     * they are git-TRACKED, which `.gitignore` cannot do (#999). The escape hatch
+     * for a committed vendor/theme/SDK directory (e.g. a checked-in Metronic theme
+     * under `static/`) that bloats the graph and slows indexing but isn't really
+     * your code. Matched against project-root-relative paths, so a directory like
+     * `"static/"`, a double-star vendor glob, or `"assets/theme"` all work.
+     * Absent/empty (the default) excludes nothing beyond the built-in defaults
+     * and your `.gitignore`.
+     */
+    exclude?: string[];
+    /**
+     * Gitignore-style patterns for first-party source to force INTO the index even
+     * when `.gitignore` would drop it — the general whitelist `includeIgnored`
+     * never was (that one only revives *embedded git repos* inside ignored dirs).
+     * The case this exists for: a project under a second VCS (SVN, Perforce, …)
+     * deliberately `.gitignore`s its own real source so it never lands in Git, yet
+     * that source must still be indexed. Matched against project-root-relative
+     * paths, so `"Tools/"`, a recursive `"Tools/**"` glob, or `"Local/typescript"`
+     * all work.
+     * Built-in default-ignored dirs (`node_modules`, `dist`, …), `.git`, and
+     * CodeGraph's own data dir are never resurfaced; an explicit `exclude` still
+     * wins. Absent/empty (the default) forces nothing in.
+     */
+    include?: string[];
+    /**
+     * Gitignore-style patterns for paths that should still be INDEXED and
+     * findable, but must not outrank first-party code in search ranking (#982).
+     *
+     * The ranking counterpart to `exclude`: `exclude` is a recall lever (the
+     * content leaves the index entirely), this is a relevance lever (the content
+     * stays, it just stops winning). It generalizes the built-in
+     * example/sample/fixture/benchmark de-prioritization to trees only the
+     * project knows about — an `optional-skills/` or `scripts/` directory whose
+     * helpers share generic symbol names with real code. Matched against
+     * project-root-relative paths, so `"optional-skills/"`, a recursive glob, or
+     * `"tools/gen"` all work. Absent/empty (the default) de-prioritizes nothing
+     * beyond the built-ins.
+     */
+    deprioritize?: string[];
+    /**
+     * baseGraph config: point this project's graph at an UPSTREAM project's
+     * already-built codegraph, so a build (`cg build` / `cg index`) snapshots that
+     * upstream graph into the local one — letting calls/references into the
+     * upstream be resolved and traversed as if they were local. `path` is the
+     * upstream PROJECT ROOT (the directory that contains its `.codegraph/` with a
+     * `codegraph.db`). Absent or empty `path` disables cross-graph merging.
+     *
+     *   {
+     *     "baseGraph": { "path": "../upstream-project" }
+     *   }
+     */
+    baseGraph?: {
+        path?: string;
+    };
+}
+/**
+ * Load the validated extension overrides for a project, mtime-cached.
+ *
+ * Returns a map of `.ext` → supported language id. The result merges on top of
+ * the built-in extension map at the point of use (see `detectLanguage` /
+ * `isSourceFile`), with these user mappings taking precedence. Returns an empty
+ * map when there is no `codegraph.json` (the zero-config default).
+ */
+export declare function loadExtensionOverrides(rootDir: string): Record<string, Language>;
+/**
+ * Load the validated `includeIgnored` patterns for a project, mtime-cached.
+ *
+ * These name gitignored directories whose embedded git repositories should be
+ * indexed despite `.gitignore` (#622, #699). An empty result — the zero-config
+ * default — means `.gitignore` is fully respected: gitignored embedded repos
+ * are never discovered or indexed (#970, #976).
+ */
+export declare function loadIncludeIgnoredPatterns(rootDir: string): string[];
+/**
+ * Load the validated `exclude` patterns for a project, mtime-cached.
+ *
+ * These name paths to keep OUT of the index even when git-tracked — the escape
+ * hatch for a committed vendor/theme/SDK directory `.gitignore` can't drop
+ * (#999). An empty result — the zero-config default — excludes nothing beyond
+ * the built-in defaults and the project's `.gitignore`.
+ */
+export declare function loadExcludePatterns(rootDir: string): string[];
+/**
+ * Load the validated `deprioritize` patterns for a project, mtime-cached.
+ *
+ * These name indexed paths that must not outrank first-party code (#982) — the
+ * ranking counterpart to `exclude`. An empty result — the zero-config default —
+ * de-prioritizes nothing beyond the built-in example/fixture/benchmark dirs.
+ */
+export declare function loadDeprioritizePatterns(rootDir: string): string[];
+/**
+ * Load the validated `include` patterns for a project, mtime-cached.
+ *
+ * These name first-party source to force INTO the index even when `.gitignore`
+ * would drop it — the whitelist for SVN/Perforce-only source a project
+ * gitignores out of Git. An empty result — the zero-config default — forces
+ * nothing in. Built-in default-ignored dirs, `.git`, and CodeGraph's data dir
+ * are never resurfaced, and an explicit `exclude` still wins.
+ */
+export declare function loadIncludePatterns(rootDir: string): string[];
+/**
+ * Load the configured upstream `baseGraph.path` for a project, mtime-cached.
+ *
+ * Returns the VERBATIM configured path (may be relative — resolve it against
+ * the project root at merge time), or '' when `codegraph.json` is absent,
+ * has no `baseGraph`, or its `path` is empty — i.e. cross-graph merging is off.
+ */
+export declare function loadBaseGraphPath(rootDir: string): string;
+/**
+ * Write a `codegraph.json` scaffold into a freshly-init'ed project so the user
+ * has a place to point at an upstream baseGraph (`"baseGraph": { "path": … }`).
+ * No-op (returns false) when a config file already exists — never clobber a
+ * config the user or another command already created. Empty `path` disables
+ * cross-graph merging, so writing it is a harmless default.
+ */
+export declare function ensureBaseGraphConfigScaffold(rootDir: string): boolean;
+/** Test/maintenance hook: forget cached config (e.g. after rewriting it in a test). */
+export declare function clearProjectConfigCache(): void;
+/**
+ * Add gitignore-style patterns to a project's `codegraph.json` `includeIgnored`
+ * list, creating the file if absent and preserving every other key. Used by the
+ * CLI to opt a "super-repo of gitignored child repos" (#1156) into the index on
+ * the user's say-so. Returns the count of patterns actually ADDED (ones already
+ * present are skipped, so a re-run is idempotent).
+ *
+ * A plain-JSON round-trip: a `codegraph.json` carrying comments (not valid JSON)
+ * already fails to load with a warning, so rather than silently clobber such a
+ * file this throws when an existing config won't parse — the caller falls back
+ * to printing the manual snippet. Invalidates the config cache so a subsequent
+ * index in the same process sees the new patterns.
+ */
+export declare function addIncludeIgnoredPatterns(rootDir: string, patterns: string[]): number;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/project-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../src/project-config.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKnC,6CAA6C;AAC7C,eAAO,MAAM,uBAAuB,mBAAmB,CAAC;AAExD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/B;AAoRD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAEhF;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAStE;AAED,uFAAuF;AACvF,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAyCrF"}