@psnext/lscg 0.1.4 → 0.1.5

package/README.md

@@ -119,9 +119,12 @@ prefix and substring matches; an ambiguous match returns ranked candidates
 instead of merging unrelated symbols. Use `--kind` and repository-relative
 `--file` to disambiguate. Results are references by default; `--excerpts` opts
 into bounded source text with `--excerpt-lines` and `--excerpt-bytes` limits.
-The command compares a cheap path/size/mtime fingerprint with indexed files and
-reports whether the graph was reused or refreshed. This metadata check is not a
-content-verification guarantee for same-size edits with restored mtimes.
+Graph-reading commands never start a scan. Their Freshness Report reflects the
+stored graph state: `fresh` after a successful explicit scan, `stale` when no
+compatible graph exists or a known invalidation remains, and `degraded` when a
+retained failed-file or plugin contribution is being served. Run `scan` or keep
+`watch` active after source changes; a stored `fresh` result is not a live
+filesystem content-verification guarantee.
 
 Impact contains only syntax-grounded `calls` edges (with caller/callee
 direction), and dependencies contain `imports`/`exports`; parser confidence
@@ -130,10 +133,70 @@ Substring fallback is intentionally reported as a bounded capability warning.
 Use `rg` or `grep` for literal discovery when a term is not indexed—`context`
 does not replace arbitrary text search or claim complete semantic resolution.
 
+`lscg scan` performs an Explicit Scan. After the first scan, its default mode
+is incremental: it retains unchanged file graphs and reprocesses files whose
+path, size, or mtime metadata changed. Use `lscg scan --full` when you need a
+complete rebuild and content verification (including same-size edits with
+restored mtimes).
+
 `lscg watch` keeps the selected repository current in the foreground. It runs
 one scan immediately, then watches scanner-relevant files and prints compact
-status updates between rescans. Use `lscg scan` when you want the full one-shot
-scan output.
+status updates between rescans. `lscg scan --watch` provides the same Watch
+Session from the scan command. Use `lscg scan` when you want the one-shot scan
+output.
+
+Pass `--progress` to `scan`, `watch`, or `scan --watch` for line-oriented,
+human-readable lifecycle messages on stderr while the existing JSON summary or
+Watch Session events remain on stdout. For example:
+
+```bash
+npm start -- scan --progress >summary.json
+npm start -- watch --progress >watch-events.jsonl
+npm start -- scan --watch --progress >watch-events.jsonl
+```
+
+Progress labels discovery/planning, plugin work, file processing,
+reconciliation, and optional enrichment. A normal scan may report structural
+completion with enrichment deferred or degraded; a Full Scan reports retries
+and only reports stabilized completion after its enrichment loop succeeds.
+Progress is informational rather than a stable machine-readable protocol, and
+it does not provide cancellation or animated progress bars.
+
+## Scan/watch benchmark
+
+Run the non-blocking benchmark with:
+
+```bash
+npm run benchmark:scan-watch
+```
+
+The versioned JSON report separates two cold timings for this lscg checkout:
+
+- `coldNormalStructuralReady`: a normal scan's return after its structural
+  graph is persisted, before optional enrichment completes.
+- `coldFullEnrichmentComplete`: a cold `scan --full` completion, including its
+  required enrichment drain.
+
+Every cold sample uses an isolated copy with no pre-existing graph database;
+source and Git metadata are copied so the normal and full scans exercise the
+same source graph and optional attribution path without changing this checkout.
+The report records SHA-256 fingerprints plus structural node/edge counts before
+normal-scan enrichment and after that scan's pending enrichment work drains.
+`structuralEquivalence` must be `true`: user nodes, `attributed_to` edges, and
+per-node attribution are
+intentionally excluded because they are optional enrichment rather than source
+structure.
+
+`coldNormalStructuralReadyTarget` reports the 3.43-second baseline, the
+2.06-second median target (the required 40% reduction), the measured p50, and
+whether that run met the target. Timing values and target status are benchmark
+results for the documented machine/run, not unit-test thresholds. Use multiple
+cold samples for review (the default is 10); pass `-- --repetitions 5` to change
+the sample count.
+
+The report also retains deterministic work counters and informational p50/p95
+timings for the isolated representative fixture's initial full scan, no-change
+incremental scan, and one-file Watch Session update.
 
 When the repository has git history, `lscg scan` also records contributor user
 nodes keyed by email and tracks the most recent contributor for each discovered
@@ -203,7 +266,22 @@ listed in `plugins`.
 
 ## Current parser support
 
-The starter scanner supports JavaScript, JSX, TypeScript, and TSX via
-Tree-sitter. The extraction layer records syntax-grounded edges such as
-`defines`, `contains`, `imports`, `exports`, and `calls`. Cross-file symbol
-resolution should be added as language-specific semantic enrichers.
+The scanner supports JavaScript, JSX, TypeScript, TSX, Python, and Java via
+Tree-sitter. Python is handled by the bundled `PythonScannerPlugin`, and Java
+by `JavaScannerPlugin` using the pinned native `tree-sitter-java@0.21.0`
+grammar. Java records syntax-grounded classes, interfaces, enums, records,
+annotation types, methods, constructors, fields, imports, method invocations,
+containment, and explicit-public export approximations. Java calls/imports are
+occurrences (no type, overload, constructor, or cross-file resolution), and
+inherited/module APIs are not modeled. A Java parse error retains the prior
+file contribution and marks freshness degraded until the file recovers.
+
+Repositories with root or immediate-module `pom.xml`, `build.gradle`, or
+`build.gradle.kts` files also receive `java-dependency` `package` nodes from
+`JavaDependencyPlugin`. Manifest reading is bounded and non-executing; only
+literal Maven coordinates/properties and literal Gradle dependency calls are
+modeled. Dependencies remain independent from Java imports: no heuristic
+coordinate matching or dependency-to-import edges are emitted. Native
+Tree-sitter install scripts must remain allowlisted for clean installs.
+Cross-file symbol resolution remains a language-specific semantic-enricher
+concern.

package/dist/src/cli-progress.d.ts

@@ -0,0 +1,7 @@
+import type { ProgressReporter } from './types.js';
+export interface ProgressWriter {
+    (text: string): void;
+}
+/** Create a deterministic, line-oriented renderer for the stderr channel. */
+export declare function createProgressReporter(write?: ProgressWriter): ProgressReporter;
+//# sourceMappingURL=cli-progress.d.ts.map

package/dist/src/cli-progress.js

@@ -0,0 +1,59 @@
+/** Create a deterministic, line-oriented renderer for the stderr channel. */
+export function createProgressReporter(write = (text) => process.stderr.write(`${text}\n`)) {
+    const skippedByAttempt = new Map();
+    return (event) => {
+        const line = event.kind === 'scan'
+            ? renderScan(event, skippedByAttempt)
+            : renderWatch(event);
+        if (line)
+            write(line);
+    };
+}
+function renderScan(event, skippedByAttempt) {
+    const prefix = `[${event.operation} scan scope=${event.scope}]`;
+    if (event.phase === 'discovery' && event.status === 'started')
+        return `${prefix} discovery/planning: discovering files`;
+    if (event.phase === 'discovery' && event.status === 'completed') {
+        const c = event.counts ?? {};
+        return `${prefix} discovery/planning: discovered=${c.discovered ?? 0} selected=${c.selected ?? 0} unchanged=${c.unchanged ?? 0} deleted=${c.deleted ?? 0}`;
+    }
+    if (event.phase === 'plugins' && event.status === 'started')
+        return `${prefix} plugin work: starting plugins=${event.counts?.plugins ?? 0}`;
+    if (event.phase === 'plugins') {
+        const c = event.counts ?? {};
+        const suffix = event.detail ? ` (${event.detail})` : '';
+        return `${prefix} plugin work: plugins=${c.plugins ?? 0} failed=${c.failedPlugins ?? 0}${suffix}`;
+    }
+    if (event.phase === 'files' && event.status === 'started')
+        return `${prefix} file processing: selected=${event.counts?.selected ?? 0}`;
+    if (event.phase === 'files' && event.status === 'processed')
+        return `${prefix} file processing: processed=${event.counts?.processed ?? 0} skipped=${event.counts?.skipped ?? 0}`;
+    if (event.phase === 'files' && event.status === 'skipped') {
+        const key = `${event.operation}:${event.attempt ?? 1}`;
+        const count = (skippedByAttempt.get(key) ?? 0) + 1;
+        skippedByAttempt.set(key, count);
+        if (count <= 3)
+            return `${prefix} warning: skipped ${event.path ?? '<unknown>'}${event.detail ? ` (${event.detail})` : ''}`;
+        if (count === 4)
+            return `${prefix} warning: additional skipped files omitted (showing first 3)`;
+        return undefined;
+    }
+    if (event.phase === 'reconciliation' && event.status === 'started')
+        return `${prefix} reconciliation: starting deleted=${event.counts?.deleted ?? 0}`;
+    if (event.phase === 'reconciliation' && event.status === 'completed')
+        return `${prefix} reconciliation: complete processed=${event.counts?.processed ?? 0} skipped=${event.counts?.skipped ?? 0}`;
+    if (event.phase === 'enrichment' && event.status === 'started')
+        return `${prefix} enrichment: starting`;
+    if (event.phase === 'enrichment') {
+        const c = event.counts ?? {};
+        return `${prefix} enrichment: ${event.status} pending=${c.pending ?? 0} complete=${c.complete ?? 0} failed=${c.failed ?? 0}${event.detail ? ` (${event.detail})` : ''}`;
+    }
+    if (event.phase === 'terminal')
+        return `${prefix} ${event.status === 'failed' ? 'ERROR' : event.status === 'degraded' ? 'warning' : 'complete'}${event.detail ? `: ${event.detail}` : ''}`;
+    return undefined;
+}
+function renderWatch(event) {
+    const prefix = `[watch mode=${event.mode} scope=${event.scope}]`;
+    return `${prefix} ${event.event}${event.detail ? `: ${event.detail}` : ''}`;
+}
+//# sourceMappingURL=cli-progress.js.map

package/dist/src/cli.js

@@ -1,6 +1,7 @@
 import { startMcpServer } from './mcp/server.js';
 import { buildViewModel, loadViewSnapshot, renderSvgMarkup, viewGraph } from './view/index.js';
 import { watchRepository } from './watch.js';
+import { createProgressReporter } from './cli-progress.js';
 import { graphStatus, initGraph, callGraph, contextGraph, listEdges, listNodes, listNodeText, neighbors, runReadOnlySql, scanRepository } from './graph/repository.js';
 const operationalCommands = new Set([
     'init', 'scan', 'watch', 'status', 'nodes', 'edges', 'neighbors',
@@ -13,19 +14,22 @@ export async function runCli(argv) {
         return;
     }
     const options = parseOptions(rest);
+    const progress = options.progress === true ? createProgressReporter() : undefined;
     switch (command) {
         case 'init':
             printJson(initGraph({ root: options.root, scope: options.scope ?? 'repo' }));
             return;
         case 'scan':
+            if (options.watch && options.full)
+                throw new Error('scan --full cannot be combined with --watch');
             if (options.watch) {
-                await watchRepository({ root: options.root, scope: options.scope ?? 'repo' }, { mode: 'scan --watch' });
+                await watchRepository({ root: options.root, scope: options.scope ?? 'repo' }, { mode: 'scan --watch', progress });
                 return;
             }
-            printJson(await scanRepository({ root: options.root, scope: options.scope ?? 'repo' }));
+            printJson(await scanRepository({ root: options.root, scope: options.scope ?? 'repo', full: options.full === true, progress }));
             return;
         case 'watch':
-            await watchRepository({ root: options.root, scope: options.scope ?? 'repo' }, { mode: 'watch' });
+            await watchRepository({ root: options.root, scope: options.scope ?? 'repo' }, { mode: 'watch', progress });
             return;
         case 'status':
             printJson(graphStatus({ root: options.root, scope: options.scope ?? 'repo' }));
@@ -238,7 +242,7 @@ function parseOptions(args) {
             continue;
         }
         const next = args[index + 1];
-        const booleanOption = key === 'watch' || key === 'attachHome' || key === 'excerpts' || key === 'help';
+        const booleanOption = key === 'watch' || key === 'full' || key === 'attachHome' || key === 'excerpts' || key === 'help' || key === 'progress';
         if (!booleanOption && next && !next.startsWith('--')) {
             options[key] = coerce(next);
             index += 1;
@@ -286,8 +290,8 @@ function validateContextOptions(options, args) {
 function commandHelpText(command) {
     const help = {
         init: `Usage: lscg init [options]\n\nCreate graph storage for the selected scope.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo|home|both      Storage scope to initialize (default: repo).\n\nExamples:\n  lscg init --scope both`,
-        scan: `Usage: lscg scan [options]\n\nParse repository files and write discovered graph data.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo|home|both      Storage scope to scan (default: repo).\n  --watch                     Watch and rescan after the initial scan.\n\nExamples:\n  lscg scan --scope both\n  lscg scan --watch`,
-        watch: `Usage: lscg watch [options]\n\nKeep the repository current by rescanning on file changes.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo                Repository scope to watch (default: repo).\n\nExamples:\n  lscg watch`,
+        scan: `Usage: lscg scan [options]\n\nParse repository files and write discovered graph data.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo|home|both      Storage scope to scan (default: repo).\n  --full                      Rebuild and verify every discovered source file.\n  --watch                     Watch and rescan after the initial scan.\n  --progress                  Write human-readable lifecycle progress to stderr.\n\nExamples:\n  lscg scan --scope both\n  lscg scan --full\n  lscg scan --watch`,
+        watch: `Usage: lscg watch [options]\n\nKeep the repository current by rescanning on file changes.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo                Repository scope to watch (default: repo).\n  --progress                  Write human-readable lifecycle progress to stderr.\n\nExamples:\n  lscg watch`,
         status: `Usage: lscg status [options]\n\nShow graph counts and database paths.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo|home|both      Storage scope to inspect (default: repo).\n\nExamples:\n  lscg status --scope repo`,
         nodes: `Usage: lscg nodes [term] [options]\n\nList graph nodes, optionally filtered by a case-insensitive name term.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo|home|both      Storage scope to inspect (default: repo).\n  --kind node-kind             Filter by node kind.\n  --limit n                   Maximum number of nodes (default: 50).\n  --output json|text           Output format (default: json).\n  -o value                    Alias for --output.\n\nExamples:\n  lscg nodes --kind user --limit 20\n  lscg nodes --output text`,
         edges: `Usage: lscg edges [options]\n\nList graph edges.\nOptions:\n  --root path                 Repository root (default: current directory).\n  --scope repo|home|both      Storage scope to inspect (default: repo).\n  --kind edge-kind             Filter by edge kind.\n  --limit n                   Maximum number of edges (default: 50).\n  --output json|text           Output format (default: json).\n  -o value                    Alias for --output.\n\nExamples:\n  lscg edges --kind calls --limit 20\n  lscg edges --output text`,
@@ -479,10 +483,13 @@ Command options:
   scan:
     --root path                 Repository root (default: current directory).
     --scope repo|home|both      Storage scope to scan (default: repo).
+    --full                      Rebuild and verify every discovered source file.
     --watch                     Watch and rescan after the initial scan.
+    --progress                  Write human-readable lifecycle progress to stderr.
   watch:
     --root path                 Repository root (default: current directory).
     --scope repo                Repository scope to watch (default: repo).
+    --progress                  Write human-readable lifecycle progress to stderr.
   status:
     --root path                 Repository root (default: current directory).
     --scope repo|home|both      Storage scope to inspect (default: repo).
@@ -570,6 +577,7 @@ Notes:
   - lscg view opens an interactive HTML page by default.
   - Pass --output to write a static SVG snapshot instead of opening the browser.
   - lscg watch supports repo scope only.
+  - --progress is opt-in human-readable diagnostics on stderr; stdout JSON is unchanged.
 
 Storage:
   repo: <root>/.sling/graph.sqlite

package/dist/src/graph/attribution.d.ts

@@ -1,8 +1,8 @@
-import type { GraphNode, FileAttribution } from '../types.js';
+import type { AttributionOutcome, GraphNode } from '../types.js';
 export declare function buildFileAttribution({ root, relativePath, source, nodes }: {
     root: string;
     relativePath: string;
     source: string;
     nodes: GraphNode[];
-}): FileAttribution | null;
+}): AttributionOutcome;
 //# sourceMappingURL=attribution.d.ts.map

package/dist/src/graph/attribution.js

@@ -1,8 +1,8 @@
 import { spawnSync } from 'node:child_process';
 export function buildFileAttribution({ root, relativePath, source, nodes }) {
-    const blameLines = blameFile(root, relativePath);
-    if (!blameLines)
-        return null;
+    const blameResult = blameFile(root, relativePath);
+    if (blameResult.status !== 'complete')
+        return blameResult;
     const lineStarts = buildLineStarts(source);
     const contributorEmails = new Map();
     const nodeAttributions = nodes.flatMap((node) => {
@@ -10,7 +10,7 @@ export function buildFileAttribution({ root, relativePath, source, nodes }) {
         const uniqueEmails = new Set();
         let latest = null;
         for (let lineNumber = span.startLine; lineNumber <= span.endLine; lineNumber += 1) {
-            const blame = blameLines[lineNumber];
+            const blame = blameResult.blameLines[lineNumber];
             if (!blame)
                 continue;
             uniqueEmails.add(blame.email);
@@ -25,19 +25,37 @@ export function buildFileAttribution({ root, relativePath, source, nodes }) {
                 lastModifiedEmail: latest?.email ?? null
             }];
     });
+    if (contributorEmails.size === 0)
+        return { status: 'unavailable', reason: 'not_applicable' };
     return {
-        contributorEmails: [...contributorEmails.values()].sort((left, right) => left.email.localeCompare(right.email)),
-        nodeAttributions
+        status: 'complete',
+        attribution: {
+            contributorEmails: [...contributorEmails.values()].sort((left, right) => left.email.localeCompare(right.email)),
+            nodeAttributions
+        }
     };
 }
 function blameFile(root, relativePath) {
-    const result = spawnSync('git', ['-C', root, 'blame', '--follow', '--line-porcelain', '--', relativePath], {
-        encoding: 'utf8'
-    });
-    if (result.error || result.status !== 0 || !result.stdout.trim()) {
-        return null;
+    let result;
+    try {
+        result = spawnSync('git', ['-C', root, 'blame', '--follow', '--line-porcelain', '--', relativePath], {
+            encoding: 'utf8'
+        });
+    }
+    catch (error) {
+        return { status: 'failed', diagnostic: `git blame failed: ${diagnosticFor(error)}` };
     }
-    const lines = result.stdout.split(/\r?\n/);
+    if (result.error)
+        return { status: 'failed', diagnostic: `git blame failed: ${diagnosticFor(result.error)}` };
+    const stdout = typeof result.stdout === 'string' ? result.stdout : result.stdout.toString('utf8');
+    const stderr = typeof result.stderr === 'string' ? result.stderr : result.stderr.toString('utf8');
+    if (result.status !== 0) {
+        const detail = stderr.trim() || `exit status ${result.status ?? 'unknown'}`;
+        return { status: 'failed', diagnostic: `git blame failed: ${detail}` };
+    }
+    if (!stdout.trim())
+        return { status: 'unavailable', reason: 'not_applicable' };
+    const lines = stdout.split(/\r?\n/);
     const blameLines = [];
     let currentEmail = null;
     let currentTimestamp = 0;
@@ -63,7 +81,12 @@ function blameFile(root, relativePath) {
             }
         }
     }
-    return blameLines.length > 0 ? blameLines : null;
+    return blameLines.length > 0
+        ? { status: 'complete', blameLines }
+        : { status: 'unavailable', reason: 'unavailable' };
+}
+function diagnosticFor(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 function isHeaderLine(line) {
     return /^[0-9a-f]{7,40} \d+ \d+(?: \d+)?$/.test(line);

package/dist/src/graph/repository.d.ts

@@ -1,4 +1,4 @@
-import type { GraphEdgeRow, GraphNodeRow, GraphNodeTextRow, NeighborRow, CallGraphMatch, RepositoryRecord, ScanSummary, StatusResult, StorageScope, ContextGraphResult } from '../types.js';
+import type { EnrichmentRunner, EnrichmentSummary, GraphEdgeRow, GraphNodeRow, GraphNodeTextRow, NeighborRow, CallGraphMatch, RepositoryRecord, ScanSummary, StatusResult, StorageScope, ContextGraphResult, FreshnessReport, ProgressReporter } from '../types.js';
 import { type PluginResourceLimits, type ScannerPlugin } from '../scanner/plugins.js';
 export declare function repositoryForRoot(root?: string | undefined): RepositoryRecord;
 export declare function initGraph({ root, scope }?: {
@@ -11,12 +11,33 @@ export declare function initGraph({ root, scope }?: {
         databasePath: string;
     }>;
 };
-export declare function scanRepository({ root, scope, plugins, pluginLimits }?: {
+export interface ScanRepositoryOptions {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
     plugins?: readonly ScannerPlugin[] | undefined;
     pluginLimits?: Partial<PluginResourceLimits> | undefined;
-}): Promise<ScanSummary>;
+    full?: boolean | undefined;
+    enrichmentRunner?: EnrichmentRunner | undefined;
+    progress?: ProgressReporter | undefined;
+    /** Internal attempt label used by the Full Scan stabilization loop. */
+    attempt?: number | undefined;
+}
+/**
+ * A full scan must not report success with hash-incompatible enrichment work.
+ * Rebuild and drain again when a source changes while attribution is running.
+ */
+export declare function scanRepository(options?: ScanRepositoryOptions): Promise<ScanSummary>;
+export declare const defaultEnrichmentRunner: EnrichmentRunner;
+export interface DrainRepositoryEnrichmentOptions {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    enrichmentRunner?: EnrichmentRunner | undefined;
+}
+/**
+ * Drains persisted, hash-compatible attribution work. This is deliberately
+ * explicit: one-shot structural scans persist work but never start it.
+ */
+export declare function drainRepositoryEnrichment({ root, scope, enrichmentRunner }?: DrainRepositoryEnrichmentOptions): Promise<EnrichmentSummary>;
 export declare function graphStatus({ root, scope }?: {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
@@ -31,6 +52,7 @@ export declare function listNodes({ root, scope, kind, limit }?: {
     limit?: number | undefined;
 }): Array<{
     scope: StorageScope;
+    freshness: FreshnessReport;
 } & GraphNodeRow>;
 export declare function listNodeText({ root, scope, kind, term, limit }?: {
     root?: string | undefined;
@@ -41,6 +63,7 @@ export declare function listNodeText({ root, scope, kind, term, limit }?: {
 }): Array<{
     scope: StorageScope;
     root: string;
+    freshness: FreshnessReport;
 } & GraphNodeTextRow>;
 export declare function listEdges({ root, scope, kind, limit }?: {
     root?: string | undefined;
@@ -49,6 +72,7 @@ export declare function listEdges({ root, scope, kind, limit }?: {
     limit?: number | undefined;
 }): Array<{
     scope: StorageScope;
+    freshness: FreshnessReport;
 } & GraphEdgeRow>;
 export declare function neighbors({ root, scope, nodeId, depth, limit }?: {
     root?: string | undefined;
@@ -58,6 +82,7 @@ export declare function neighbors({ root, scope, nodeId, depth, limit }?: {
     limit?: number | undefined;
 }): Array<{
     scope: StorageScope;
+    freshness: FreshnessReport;
 } & NeighborRow>;
 export declare function callGraph({ root, scope, term, kind, depth, limit }?: {
     root?: string | undefined;
@@ -68,6 +93,7 @@ export declare function callGraph({ root, scope, term, kind, depth, limit }?: {
     limit?: number | undefined;
 }): Array<{
     scope: StorageScope;
+    freshness: FreshnessReport;
 } & CallGraphMatch>;
 export interface ContextGraphOptions {
     root?: string | undefined;
@@ -92,5 +118,6 @@ export declare function runReadOnlySql({ root, scope, sql, attachHome, limit }?:
 }): Array<{
     scope: StorageScope;
     rows: unknown[];
+    freshness: FreshnessReport;
 }>;
 //# sourceMappingURL=repository.d.ts.map