@zivis/cli 0.1.0-alpha.39 → 0.1.0-alpha.4

package/dist/commands/inspect/index.js

@@ -1,136 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { detectProjectBinding } from "@zivis/mcp/project-binding";
-import { runExtractor } from "../../internal/extractor/index.js";
-import { buildRepoGraphArtifact } from "../../internal/extractor/graph-builder.js";
-const execAsync = promisify(exec);
-function collect(value, previous) {
-    return previous.concat([value]);
-}
-export function registerInspectCommands(program) {
-    program
-        .command("inspect")
-        .description("build a local repo graph artifact (services, endpoints, external deps) — local-only, no network")
-        .option("--root <dir>", "repo root to inspect (default: cwd)")
-        .option("--out <file>", "write artifact JSON to a file (default: <user-cache>/repos/<repo-id>/inspect/runs/<run-id>.json; '-' for stdout)")
-        .option("--privacy-audit", "print exactly what would be sent without writing to cache or sending — never makes network calls")
-        .option("--lang <list>", "comma-separated subset of adapters: typescript,go,python")
-        .option("--ignore <pattern>", "extra ignore pattern (repeatable)", collect, [])
-        .option("--application <id>", "set provenance.application_id (default: from .zivis/project.json if present)")
-        .option("--repo-id <id>", "override repo identifier (default: hash of git remote, fallback to hash of root path)")
-        .option("--commit <sha>", "override commit SHA (default: from `git rev-parse HEAD`)")
-        .option("--branch <name>", "override branch (default: from `git rev-parse --abbrev-ref HEAD`)")
-        .action(async (opts) => {
-        const rootDir = path.resolve(opts.root ?? process.cwd());
-        const cliPkg = await readCliPackage();
-        const langs = opts.lang
-            ? String(opts.lang).split(",").map((s) => s.trim()).filter(Boolean)
-            : undefined;
-        const result = await runExtractor({
-            rootDir,
-            languages: langs,
-            extraIgnores: opts.ignore,
-            extractorVersion: cliPkg.version,
-        });
-        const gitMeta = await readGitMetadata(rootDir);
-        const applicationId = opts.application ?? detectProjectBinding(rootDir)?.binding.applicationId;
-        const repoId = opts.repoId ?? deriveRepoId(gitMeta.remoteUrl, rootDir);
-        const commitSha = opts.commit ?? gitMeta.commitSha;
-        const branch = opts.branch ?? gitMeta.branch;
-        const artifact = buildRepoGraphArtifact(result, {
-            applicationId,
-            repoId,
-            commitSha,
-            branch,
-            analysisMode: "local",
-        });
-        if (opts.privacyAudit) {
-            process.stdout.write(JSON.stringify(artifact, null, 2) + "\n");
-            printSummary(artifact, "PRIVACY AUDIT — nothing was written or sent");
-            return;
-        }
-        if (opts.out === "-") {
-            process.stdout.write(JSON.stringify(artifact, null, 2) + "\n");
-            printSummary(artifact);
-            return;
-        }
-        const outPath = opts.out
-            ? path.isAbsolute(opts.out)
-                ? opts.out
-                : path.join(rootDir, opts.out)
-            : defaultCacheOutPath(repoId, commitSha, artifact.extracted_at);
-        await fs.mkdir(path.dirname(outPath), { recursive: true });
-        await fs.writeFile(outPath, JSON.stringify(artifact, null, 2) + "\n");
-        printSummary(artifact, `wrote ${outPath}`);
-    });
-}
-async function readCliPackage() {
-    const here = path.dirname(new URL(import.meta.url).pathname);
-    const pkgPath = path.join(here, "../../../package.json");
-    const raw = await fs.readFile(pkgPath, "utf8");
-    return JSON.parse(raw);
-}
-async function readGitMetadata(rootDir) {
-    const out = {};
-    out.remoteUrl = await tryGit(rootDir, "remote get-url origin");
-    out.commitSha = await tryGit(rootDir, "rev-parse HEAD");
-    out.branch = await tryGit(rootDir, "rev-parse --abbrev-ref HEAD");
-    return out;
-}
-async function tryGit(cwd, args) {
-    try {
-        const { stdout } = await execAsync(`git ${args}`, { cwd });
-        const value = stdout.trim();
-        return value || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function deriveRepoId(remoteUrl, rootDir) {
-    if (remoteUrl) {
-        return "remote-" + sha256Short(remoteUrl);
-    }
-    return "path-" + sha256Short(rootDir);
-}
-function sha256Short(value) {
-    return crypto.createHash("sha256").update(value).digest("hex").slice(0, 16);
-}
-function userCacheRoot() {
-    const home = os.homedir();
-    if (process.platform === "darwin") {
-        return path.join(home, "Library", "Caches", "zivis");
-    }
-    if (process.platform === "win32") {
-        const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
-        return path.join(localAppData, "zivis", "Cache");
-    }
-    const xdg = process.env.XDG_CACHE_HOME;
-    return path.join(xdg ?? path.join(home, ".cache"), "zivis");
-}
-function defaultCacheOutPath(repoId, commitSha, extractedAt) {
-    const runId = formatRunId(commitSha, extractedAt);
-    return path.join(userCacheRoot(), "repos", repoId, "inspect", "runs", `${runId}.json`);
-}
-function formatRunId(commitSha, extractedAt) {
-    const compactTs = extractedAt.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-    if (!commitSha)
-        return `nogit-${compactTs}`;
-    return `${commitSha.slice(0, 7)}-${compactTs}`;
-}
-function printSummary(artifact, suffix) {
-    const services = artifact.nodes.filter((n) => n.type === "service").length;
-    const endpoints = artifact.nodes.filter((n) => n.type === "endpoint").length;
-    const deps = artifact.nodes.filter((n) => n.type === "external_dependency").length;
-    const exposes = artifact.edges.filter((e) => e.type === "exposes").length;
-    const dependsOn = artifact.edges.filter((e) => e.type === "depends_on").length;
-    const langs = artifact.scope.languages?.join(",") ?? "(none)";
-    process.stderr.write(`\n[zivis inspect] ${artifact.scope.files_scanned} files scanned in ${artifact.scope.duration_ms}ms (langs: ${langs})\n` +
-        `  ${artifact.nodes.length} nodes  (${services} services, ${endpoints} endpoints, ${deps} external deps)\n` +
-        `  ${artifact.edges.length} edges  (${exposes} exposes, ${dependsOn} depends_on)\n` +
-        (suffix ? `  ${suffix}\n` : ""));
-}

package/dist/internal/binding-token-mint.d.ts

@@ -1,33 +0,0 @@
-import { type ZivisConfig } from "@zivis/mcp/types";
-export type MintBindingTokenResult = {
-    ok: true;
-    keyName: string;
-    key: string;
-    orgName: string;
-    workosOrgId: string;
-} | {
-    ok: false;
-    error: string;
-};
-export declare function mintLocalProjectBindingToken(params: {
-    config: ZivisConfig;
-    session: string;
-    accessToken: string;
-    cwd: string;
-}): Promise<MintBindingTokenResult>;
-export interface TryAutoMintOptions {
-    cwd: string;
-    sessionName: string;
-    accessToken: string;
-    skip?: boolean;
-    warnOnFailure: boolean;
-}
-export declare function tryAutoMintBindingTokenAfterLogin(opts: TryAutoMintOptions): Promise<{
-    ran: boolean;
-    ok: boolean;
-    message?: string;
-}>;
-export declare function discardOauthAfterLogin(params: {
-    session: string | undefined;
-    config: ZivisConfig;
-}): Promise<void>;

package/dist/internal/binding-token-mint.js

@@ -1,174 +0,0 @@
-import * as os from "node:os";
-import * as crypto from "node:crypto";
-import * as child_process from "node:child_process";
-import { getSessionAccount, keychainClearSession, keychainRead, keychainStore, } from "@zivis/mcp/auth";
-import { decodeJwtPayload } from "@zivis/mcp/auth/jwt";
-import { DEFAULT_CONFIG, credentialStorageFromConfig } from "@zivis/mcp/types";
-import { detectProjectBinding, resolveConfigFromBinding } from "@zivis/mcp/project-binding";
-function getRepoFingerprint(cwd) {
-    try {
-        const remote = child_process
-            .execSync("git remote get-url origin 2>/dev/null", { cwd, encoding: "utf8" })
-            .trim();
-        if (remote) {
-            return crypto.createHash("sha256").update(remote).digest("hex").slice(0, 12);
-        }
-    }
-    catch {
-    }
-    return crypto.createHash("sha256").update(cwd).digest("hex").slice(0, 12);
-}
-export async function mintLocalProjectBindingToken(params) {
-    const { config, session, accessToken, cwd } = params;
-    const credentialStorage = credentialStorageFromConfig(config);
-    const repoFingerprint = getRepoFingerprint(cwd);
-    const hostname = os.hostname();
-    let bindResult;
-    try {
-        const response = await fetch(`${config.apiBaseUrl}/api/auth/bind`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                "Content-Type": "application/json",
-                "User-Agent": "@zivis/cli",
-            },
-            body: JSON.stringify({ repoFingerprint, hostname }),
-        });
-        if (!response.ok) {
-            const body = (await response.json().catch(() => ({})));
-            return {
-                ok: false,
-                error: body.message ?? body.error ?? `HTTP ${response.status}`,
-            };
-        }
-        bindResult = (await response.json());
-    }
-    catch (err) {
-        return {
-            ok: false,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-    const apiKeyAccount = `apikey.${session}`;
-    try {
-        await keychainStore(apiKeyAccount, bindResult.key, credentialStorage);
-    }
-    catch (err) {
-        return {
-            ok: false,
-            error: err instanceof Error ? err.message : "Failed to store key in OS keychain",
-        };
-    }
-    return {
-        ok: true,
-        keyName: bindResult.keyName,
-        key: bindResult.key,
-        orgName: bindResult.orgName,
-        workosOrgId: bindResult.workosOrgId,
-    };
-}
-export async function tryAutoMintBindingTokenAfterLogin(opts) {
-    if (opts.skip) {
-        return { ran: false, ok: true };
-    }
-    const fullConfig = { ...DEFAULT_CONFIG, ...resolveConfigFromBinding(opts.cwd) };
-    const claims = decodeJwtPayload(opts.accessToken);
-    const jwtOrgId = claims?.org_id;
-    if (!jwtOrgId) {
-        return {
-            ran: false,
-            ok: true,
-            message: "JWT has no org_id — skipped MCP binding-key mint.",
-        };
-    }
-    const detected = detectProjectBinding(opts.cwd);
-    const bindingOrg = detected?.binding.workosOrgId;
-    const bindingSession = detected?.binding.session;
-    if (!bindingOrg || !bindingSession) {
-        return {
-            ran: false,
-            ok: true,
-            message: "No project binding with workosOrgId — skipped MCP binding-key mint.",
-        };
-    }
-    if (bindingOrg !== jwtOrgId) {
-        const msg = `JWT org does not match project binding — skipped MCP binding-key mint.`;
-        if (opts.warnOnFailure) {
-            console.log("");
-            console.log(`  WARNING: ${msg}`);
-        }
-        return { ran: false, ok: false, message: msg };
-    }
-    if (bindingSession !== opts.sessionName) {
-        const msg = `Session "${opts.sessionName}" does not match binding session "${bindingSession}" — skipped MCP binding-key mint.`;
-        if (opts.warnOnFailure) {
-            console.log("");
-            console.log(`  WARNING: ${msg}`);
-        }
-        return { ran: false, ok: false, message: msg };
-    }
-    const st = credentialStorageFromConfig(fullConfig);
-    const existing = await keychainRead(`apikey.${bindingSession}`, st).catch(() => null);
-    if (existing) {
-        console.log("");
-        console.log(`✓ MCP API key already present for session "${bindingSession}" — skipped mint.`);
-        return { ran: false, ok: true };
-    }
-    console.log("");
-    console.log("Minting Local Project Binding Token for MCP (one-time per machine/session)…");
-    const result = await mintLocalProjectBindingToken({
-        config: fullConfig,
-        session: bindingSession,
-        accessToken: opts.accessToken,
-        cwd: opts.cwd,
-    });
-    if (!result.ok) {
-        const msg = result.error;
-        if (opts.warnOnFailure) {
-            printMintFailureBanner(msg);
-        }
-        return { ran: true, ok: false, message: msg };
-    }
-    console.log(`✓ MCP API key stored (${result.keyName}; org: ${result.orgName})`);
-    return { ran: true, ok: true };
-}
-export async function discardOauthAfterLogin(params) {
-    const storage = credentialStorageFromConfig(params.config);
-    try {
-        await keychainClearSession(params.session, storage);
-    }
-    catch {
-    }
-    const leftover = await keychainRead(getSessionAccount(params.session), storage).catch(() => null);
-    if (leftover) {
-        const account = getSessionAccount(params.session);
-        const service = `${storage.keychainPrefix}.${account}`;
-        console.error("");
-        console.error(`  WARNING: OAuth tokens are still present in the keychain (${service}).`);
-        console.error("  Possible cause: keychain access was denied, or older builds left");
-        console.error("  duplicate entries that the OS doesn't surface in a single delete.");
-        console.error("  Force-clean with:");
-        console.error(`    while security delete-generic-password -a zivis-mcp -s '${service}' 2>/dev/null; do :; done`);
-        console.error("");
-    }
-}
-function printMintFailureBanner(message) {
-    const bar = "═".repeat(70);
-    console.error("");
-    console.error(bar);
-    console.error("  ACTION REQUIRED — MCP API KEY WAS NOT MINTED");
-    console.error(bar);
-    console.error("");
-    console.error(`  Reason: ${message}`);
-    console.error("");
-    console.error("  Why this matters:");
-    console.error("    The MCP server in your IDE authenticates with an org-scoped");
-    console.error("    API key. Without it, every zivis_* tool call will fail with");
-    console.error("    \"Not authenticated\" until you mint one.");
-    console.error("");
-    console.error("  To fix, run from this repo:");
-    console.error("    zivis auth bind");
-    console.error("");
-    console.error(bar);
-    console.error("");
-}

package/dist/internal/extractor/graph-builder.d.ts

@@ -1,10 +0,0 @@
-import type { ExtractionResult } from "./types.js";
-import type { RepoGraphArtifactV1, AnalysisMode } from "./graph-types.js";
-export interface BuildOptions {
-    applicationId?: string;
-    repoId?: string;
-    commitSha?: string;
-    branch?: string;
-    analysisMode?: AnalysisMode;
-}
-export declare function buildRepoGraphArtifact(result: ExtractionResult, opts?: BuildOptions): RepoGraphArtifactV1;

package/dist/internal/extractor/graph-builder.js

@@ -1,245 +0,0 @@
-const TRUSTED_LANE = "trusted";
-const TRUSTED_SOURCE = "inspect.trusted";
-export function buildRepoGraphArtifact(result, opts = {}) {
-    const nodes = [];
-    const edges = [];
-    const serviceById = new Map();
-    for (const component of result.components) {
-        if (component.kind === "external_service" || component.kind === "data_store") {
-            continue;
-        }
-        if (component.evidence.length === 0)
-            continue;
-        const node = buildServiceNode(component);
-        serviceById.set(node.id, node);
-        nodes.push(node);
-    }
-    for (const component of result.components) {
-        const owningServiceId = serviceIdFor(component);
-        if (!serviceById.has(owningServiceId))
-            continue;
-        const seenEndpoints = new Set();
-        for (const ev of component.evidence) {
-            if (ev.kind !== "http_route")
-                continue;
-            const method = canonicalMethod(ev.method);
-            if (!method)
-                continue;
-            const endpointNode = buildEndpointNode(owningServiceId, component.language, ev, method);
-            if (seenEndpoints.has(endpointNode.id))
-                continue;
-            seenEndpoints.add(endpointNode.id);
-            nodes.push(endpointNode);
-            edges.push(buildExposesEdge(owningServiceId, endpointNode.id, ev));
-        }
-    }
-    const manifestEvidenceByPackage = indexManifestsByPackage(result);
-    const depById = new Map();
-    for (const ext of result.externalServices) {
-        const node = buildExternalDependencyNode(ext, manifestEvidenceByPackage.get(ext.package) ?? []);
-        if (depById.has(node.id))
-            continue;
-        if (node.evidence.length === 0)
-            continue;
-        depById.set(node.id, node);
-        nodes.push(node);
-    }
-    const fileToServiceId = buildFileToServiceIndex(result.components, serviceById);
-    for (const ext of result.externalServices) {
-        const depId = externalDepId(ext);
-        const seenServiceIds = new Set();
-        const evidenceByService = new Map();
-        for (const callSite of ext.callSites) {
-            const serviceId = fileToServiceId.get(callSite.file);
-            if (!serviceId)
-                continue;
-            seenServiceIds.add(serviceId);
-            const list = evidenceByService.get(serviceId) ?? [];
-            list.push(toImportEvidence(callSite, ext.package));
-            evidenceByService.set(serviceId, list);
-        }
-        for (const serviceId of seenServiceIds) {
-            edges.push(buildDependsOnEdge(serviceId, depId, evidenceByService.get(serviceId) ?? []));
-        }
-    }
-    const provenance = {
-        root_dir: result.scope.rootDir,
-        analysis_mode: opts.analysisMode ?? "local",
-        ...(opts.repoId ? { repo_id: opts.repoId } : {}),
-        ...(opts.commitSha ? { commit_sha: opts.commitSha } : {}),
-        ...(opts.branch ? { branch: opts.branch } : {}),
-        ...(opts.applicationId ? { application_id: opts.applicationId } : {}),
-    };
-    const languagesFromManifests = new Set(result.manifests.map((m) => normalizeLanguage(m.language)).filter(Boolean));
-    return {
-        version: "1.0.0",
-        kind: "repo_graph_artifact",
-        extracted_at: result.extractedAt,
-        extractor: result.extractor,
-        provenance,
-        scope: {
-            files_scanned: result.scope.filesScanned,
-            files_skipped: result.scope.filesSkipped,
-            duration_ms: result.scope.durationMs,
-            languages: [...languagesFromManifests],
-        },
-        nodes,
-        edges,
-    };
-}
-function buildServiceNode(component) {
-    const id = serviceIdFor(component);
-    return {
-        id,
-        type: "service",
-        name: component.name,
-        lane: TRUSTED_LANE,
-        source: TRUSTED_SOURCE,
-        confidence: 1,
-        language: normalizeLanguage(component.language),
-        evidence: component.evidence.map(toEvidenceSpan),
-        attributes: {
-            ...(component.framework ? { framework: component.framework } : {}),
-            source_files: component.sourceFiles,
-        },
-    };
-}
-function buildEndpointNode(serviceId, language, ev, method) {
-    const id = `endpoint::${stripPrefix(serviceId, "service::")}::${method}::${ev.path}`;
-    return {
-        id,
-        type: "endpoint",
-        name: `${method} ${ev.path}`,
-        lane: TRUSTED_LANE,
-        source: TRUSTED_SOURCE,
-        confidence: 1,
-        language: normalizeLanguage(language),
-        evidence: [toEvidenceSpan(ev)],
-        attributes: { method, path: ev.path },
-    };
-}
-function buildExternalDependencyNode(ext, manifestFallback) {
-    const registry = registryFor(ext);
-    const evidence = ext.callSites.length > 0
-        ? ext.callSites.map((cs) => toImportEvidence(cs, ext.package))
-        : manifestFallback;
-    return {
-        id: externalDepId(ext),
-        type: "external_dependency",
-        name: ext.name,
-        lane: TRUSTED_LANE,
-        source: TRUSTED_SOURCE,
-        confidence: 1,
-        evidence,
-        attributes: {
-            package: ext.package,
-            registry,
-            ...(ext.version ? { version: ext.version } : {}),
-            ...(ext.kind ? { kind: ext.kind } : {}),
-        },
-    };
-}
-function indexManifestsByPackage(result) {
-    const idx = new Map();
-    for (const m of result.manifests) {
-        for (const pkg of Object.keys(m.dependencies)) {
-            const span = { file: m.file, kind: "manifest", detail: { package: pkg } };
-            const list = idx.get(pkg) ?? [];
-            list.push(span);
-            idx.set(pkg, list);
-        }
-    }
-    return idx;
-}
-function buildExposesEdge(serviceId, endpointId, ev) {
-    return {
-        id: `exposes::${serviceId}::${endpointId}`,
-        type: "exposes",
-        source_id: serviceId,
-        target_id: endpointId,
-        lane: TRUSTED_LANE,
-        source: TRUSTED_SOURCE,
-        confidence: 1,
-        evidence: [toEvidenceSpan(ev)],
-    };
-}
-function buildDependsOnEdge(serviceId, depId, evidence) {
-    return {
-        id: `depends_on::${serviceId}::${depId}`,
-        type: "depends_on",
-        source_id: serviceId,
-        target_id: depId,
-        lane: TRUSTED_LANE,
-        source: TRUSTED_SOURCE,
-        confidence: 1,
-        evidence,
-    };
-}
-function serviceIdFor(component) {
-    return `service::${component.language}::${component.name}`;
-}
-function externalDepId(ext) {
-    const registry = registryFor(ext);
-    return `external_dependency::${registry}::${ext.package}`;
-}
-function registryFor(ext) {
-    if (ext.package.startsWith("github.com/"))
-        return "go";
-    if (ext.package.startsWith("@") || /^[a-z0-9-]+$/.test(ext.package)) {
-        return "npm";
-    }
-    return "npm";
-}
-const CANONICAL_METHODS = new Set([
-    "GET",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "HEAD",
-    "OPTIONS",
-    "WS",
-    "SSE",
-    "RPC",
-]);
-function canonicalMethod(method) {
-    const upper = method.toUpperCase();
-    return CANONICAL_METHODS.has(upper) ? upper : undefined;
-}
-function normalizeLanguage(lang) {
-    return lang;
-}
-function buildFileToServiceIndex(components, servicesById) {
-    const idx = new Map();
-    for (const component of components) {
-        const id = serviceIdFor(component);
-        if (!servicesById.has(id))
-            continue;
-        for (const file of component.sourceFiles) {
-            if (!idx.has(file))
-                idx.set(file, id);
-        }
-    }
-    return idx;
-}
-function toEvidenceSpan(ev) {
-    const base = { file: ev.file, start_line: ev.line, kind: ev.kind };
-    if (ev.kind === "http_route") {
-        return { ...base, detail: { method: ev.method, path: ev.path } };
-    }
-    if (ev.kind === "import") {
-        return { ...base, detail: { package: ev.package } };
-    }
-    return base;
-}
-function toImportEvidence(loc, pkg) {
-    return {
-        file: loc.file,
-        start_line: loc.line,
-        kind: "import",
-        detail: { package: pkg },
-    };
-}
-function stripPrefix(value, prefix) {
-    return value.startsWith(prefix) ? value.slice(prefix.length) : value;
-}

package/dist/internal/extractor/graph-types.d.ts

@@ -1,89 +0,0 @@
-export type Lane = "trusted" | "inferred";
-export type Source = "inspect.trusted" | "inspect.inferred";
-export type GraphLanguage = "typescript" | "javascript" | "python" | "go";
-export type AnalysisMode = "local" | "cloud";
-export type EvidenceKind = "import" | "http_route" | "config" | "manifest" | "decorator" | "annotation";
-export type NodeType = "service" | "endpoint" | "external_dependency";
-export type EdgeType = "exposes" | "depends_on";
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "WS" | "SSE" | "RPC";
-export type DependencyRegistry = "npm" | "pypi" | "go";
-export interface EvidenceSpan {
-    file: string;
-    start_line?: number;
-    end_line?: number;
-    kind: EvidenceKind;
-    detail?: Record<string, unknown>;
-}
-export interface ServiceAttributes {
-    framework?: string;
-    source_files?: string[];
-}
-export interface EndpointAttributes {
-    method: HttpMethod;
-    path: string;
-}
-export interface ExternalDependencyAttributes {
-    package: string;
-    version?: string;
-    registry: DependencyRegistry;
-    kind?: string;
-}
-export type NodeAttributes = ServiceAttributes | EndpointAttributes | ExternalDependencyAttributes;
-interface BaseNode {
-    id: string;
-    name: string;
-    lane: Lane;
-    source: Source;
-    confidence?: number;
-    language?: GraphLanguage;
-    evidence: EvidenceSpan[];
-}
-export interface ServiceNode extends BaseNode {
-    type: "service";
-    attributes?: ServiceAttributes;
-}
-export interface EndpointNode extends BaseNode {
-    type: "endpoint";
-    attributes: EndpointAttributes;
-}
-export interface ExternalDependencyNode extends BaseNode {
-    type: "external_dependency";
-    attributes: ExternalDependencyAttributes;
-}
-export type GraphNode = ServiceNode | EndpointNode | ExternalDependencyNode;
-export interface GraphEdge {
-    id: string;
-    type: EdgeType;
-    source_id: string;
-    target_id: string;
-    lane: Lane;
-    source: Source;
-    confidence?: number;
-    evidence?: EvidenceSpan[];
-    attributes?: Record<string, unknown>;
-}
-export interface GraphProvenance {
-    root_dir: string;
-    repo_id?: string;
-    commit_sha?: string;
-    branch?: string;
-    application_id?: string;
-    analysis_mode: AnalysisMode;
-}
-export interface GraphScope {
-    files_scanned: number;
-    files_skipped: number;
-    duration_ms: number;
-    languages?: GraphLanguage[];
-}
-export interface RepoGraphArtifactV1 {
-    version: "1.0.0";
-    kind: "repo_graph_artifact";
-    extracted_at: string;
-    extractor: string;
-    provenance: GraphProvenance;
-    scope: GraphScope;
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-}
-export {};

package/dist/internal/extractor/graph-types.js

@@ -1 +0,0 @@
-export {};