kubeagent 0.1.0

package/dist/onboard/index.js

@@ -0,0 +1,328 @@
+import chalk from "chalk";
+import ora from "ora";
+import { scanCluster, formatClusterMarkdown } from "./cluster-scan.js";
+import { detectTechStack, formatProjectMarkdown } from "./code-scan.js";
+import { scanProjectDirectory, matchProjectsToWorkloads, bestMatches } from "./project-matcher.js";
+import { runInterview } from "./interview.js";
+import { writeClusterKb, writeProjectKb, ensureKbDir } from "../kb/writer.js";
+import { saveConfig, loadConfig, configDir, ALL_ACTIONS, DEFAULT_SAFE_ACTIONS } from "../config.js";
+import { interactiveAddChannel } from "../notify/setup.js";
+import { pickContext } from "../kubectl-config.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import readline from "node:readline";
+function expandPath(p) {
+    return p.startsWith("~/") ? homedir() + p.slice(1) : p;
+}
+async function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(chalk.cyan(`${question} `), (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+const ACTION_DESCRIPTIONS = {
+    restart_pod: "Delete a pod (recreated automatically if owned by a Deployment/DaemonSet)",
+    rollout_restart: "Rolling restart of a Deployment",
+    scale_deployment: "Scale a Deployment to a different replica count",
+    set_resources: "Change CPU/memory requests and limits on a Deployment",
+};
+async function configureSafeActions(current) {
+    console.log(chalk.bold("\nAuto-approved actions (no confirmation required):\n"));
+    ALL_ACTIONS.forEach((action, i) => {
+        const enabled = current.includes(action);
+        const status = enabled ? chalk.green("[enabled] ") : chalk.dim("[disabled]");
+        console.log(`  ${chalk.cyan(String(i + 1))}. ${status} ${action}`);
+        console.log(chalk.dim(`        ${ACTION_DESCRIPTIONS[action]}`));
+    });
+    console.log(chalk.dim(`\nEnter numbers to toggle (e.g. "1 3"), or press Enter to keep current settings:`));
+    const answer = await ask("Toggle actions:");
+    if (!answer)
+        return current;
+    const toggled = new Set(current);
+    for (const token of answer.split(/[\s,]+/)) {
+        const idx = parseInt(token, 10) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= ALL_ACTIONS.length)
+            continue;
+        const action = ALL_ACTIONS[idx];
+        if (toggled.has(action))
+            toggled.delete(action);
+        else
+            toggled.add(action);
+    }
+    const result = ALL_ACTIONS.filter((a) => toggled.has(a));
+    console.log(chalk.dim(`Safe actions set to: ${result.length > 0 ? result.join(", ") : "(none — all require approval)"}`));
+    return result;
+}
+export async function onboard() {
+    console.log(chalk.bold("\nKubeAgent Onboarding\n"));
+    // Step 1: Pick cluster context from list
+    const context = await pickContext();
+    const kubectlOpts = context ? { context } : {};
+    const contextName = context || "default";
+    // Step 2: Scan cluster
+    const spinner = ora("Scanning cluster...").start();
+    let clusterInfo;
+    try {
+        clusterInfo = await scanCluster(kubectlOpts);
+        spinner.succeed(`Found ${clusterInfo.nodes.length} nodes, ${clusterInfo.deployments.length} deployments, ${clusterInfo.namespaces.length} namespaces`);
+    }
+    catch (err) {
+        spinner.fail(`Cluster scan failed: ${err.message}`);
+        return;
+    }
+    // Step 3: Discover projects — scan a directory or enter paths manually
+    const HIGH_CONFIDENCE = 60;
+    const codePaths = [];
+    const projectMappings = [];
+    // Check for existing mappings for this context
+    const existingConfig = loadConfig();
+    const existingCluster = existingConfig.clusters.find((c) => c.context === contextName);
+    const existingMappings = existingCluster?.projects ?? [];
+    if (existingMappings.length > 0) {
+        console.log(chalk.bold(`\nExisting project mappings for "${contextName}":\n`));
+        for (const m of existingMappings) {
+            console.log(`  ${chalk.green("✓")} ${m.name}  →  ${m.kind}/${m.namespace}/${m.deployment}`);
+        }
+        const rescan = await ask("\nRe-scan projects? [y/N]");
+        if (rescan.toLowerCase() !== "y") {
+            // Carry forward existing mappings
+            codePaths.push(...existingMappings.map((m) => ({ name: m.name, path: m.dir })));
+            projectMappings.push(...existingMappings);
+            // Skip to interview
+            const projects = codePaths.map(({ name, path }) => ({ name, path, stack: detectTechStack(path) }));
+            const notes = await runInterview({ cluster: clusterInfo, projects });
+            const kbDir = join(configDir(), "clusters", contextName);
+            ensureKbDir(kbDir);
+            writeClusterKb(kbDir, formatClusterMarkdown(clusterInfo));
+            for (const p of projects) {
+                const mapping = projectMappings.find((m) => m.name === p.name);
+                const mappingNote = mapping ? `**Deployment:** ${mapping.deployment} (${mapping.namespace})\n**Kind:** ${mapping.kind}` : undefined;
+                writeProjectKb(kbDir, p.name, formatProjectMarkdown(p.name, p.path, p.stack, mappingNote));
+            }
+            if (notes.size > 0) {
+                writeProjectKb(kbDir, "_notes", `# Onboarding Notes\n\n${Array.from(notes.entries()).map(([q, a]) => `**${q}**\n${a}`).join("\n\n")}\n`);
+            }
+            const currentSafeActions = existingConfig.remediation?.safe_actions ?? DEFAULT_SAFE_ACTIONS;
+            const safeActions = await configureSafeActions(currentSafeActions);
+            const existingChannels = existingConfig.notifications?.channels ?? [];
+            const newChannels = [...existingChannels];
+            console.log(chalk.bold("\nNotifications\n"));
+            if (existingChannels.length > 0) {
+                console.log(chalk.dim(`  ${existingChannels.length} channel(s) already configured.`));
+            }
+            const addNotify = await ask("Set up a notification channel (Slack / Telegram)? [y/N]");
+            if (addNotify.toLowerCase() === "y") {
+                let adding = true;
+                while (adding) {
+                    const channel = await interactiveAddChannel();
+                    if (channel)
+                        newChannels.push(channel);
+                    const another = await ask("Add another channel? [y/N]");
+                    adding = another.toLowerCase() === "y";
+                }
+            }
+            else {
+                console.log(chalk.dim("  Skipped. Run: kubeagent notify add to set up later."));
+            }
+            saveConfig({
+                ...existingConfig,
+                remediation: { ...existingConfig.remediation, safe_actions: safeActions },
+                notifications: { ...existingConfig.notifications, channels: newChannels },
+                clusters: existingConfig.clusters.map((c) => c.context === contextName ? { ...c, codepaths: codePaths.map((p) => p.path) } : c),
+            });
+            console.log(chalk.green(`\nKnowledge base written to ${kbDir}`));
+            console.log(chalk.green(`Config saved to ${configDir()}/config.yaml`));
+            console.log(chalk.dim("\nRun `kubeagent watch` to start monitoring."));
+            return;
+        }
+        console.log();
+    }
+    console.log(chalk.dim("How would you like to add your code repositories?"));
+    console.log(`  ${chalk.cyan("1")}. Scan a parent directory (auto-detect projects)`);
+    console.log(`  ${chalk.cyan("2")}. Enter paths manually`);
+    console.log(`  ${chalk.cyan("3")}. Skip\n`);
+    const modeAnswer = await ask("Choice [1]:");
+    const mode = modeAnswer === "2" ? "manual" : modeAnswer === "3" ? "skip" : "scan";
+    if (mode === "scan") {
+        const parentDirRaw = await ask("Parent directory to scan:");
+        const parentDir = expandPath(parentDirRaw);
+        if (parentDir) {
+            const scanSpinner = ora("Scanning project directories...").start();
+            const candidates = scanProjectDirectory(parentDir);
+            scanSpinner.succeed(`Found ${candidates.length} project(s)`);
+            if (candidates.length > 0) {
+                const suggestions = matchProjectsToWorkloads(candidates, clusterInfo.deployments, clusterInfo.statefulsets);
+                const matches = bestMatches(suggestions, 30);
+                // Group by project
+                const grouped = new Map();
+                for (const m of matches) {
+                    if (!grouped.has(m.project.dir))
+                        grouped.set(m.project.dir, []);
+                    grouped.get(m.project.dir).push(m);
+                }
+                console.log(chalk.bold("\nProject → deployment suggestions:\n"));
+                for (const [, ms] of grouped) {
+                    const best = ms[0];
+                    const isHigh = best.score >= HIGH_CONFIDENCE;
+                    const confidence = isHigh ? chalk.green("high") : best.score >= 40 ? chalk.yellow("medium") : chalk.red("low");
+                    console.log(`  ${chalk.bold(best.project.name + "/")}  →  ${best.workload.namespace}/${best.workload.name}  [${confidence}]`);
+                    console.log(chalk.dim(`    ${best.reasons[0]}`));
+                    if (isHigh) {
+                        // Auto-accept high confidence
+                        codePaths.push({ name: best.project.name, path: best.project.dir });
+                        projectMappings.push({
+                            name: best.project.name,
+                            dir: best.project.dir,
+                            deployment: best.workload.name,
+                            namespace: best.workload.namespace,
+                            kind: best.workload.kind,
+                        });
+                        console.log(chalk.dim("    Auto-accepted.\n"));
+                    }
+                    else {
+                        // Ask for medium/low
+                        const ans = await ask("    Accept this mapping? [y/N]");
+                        if (ans.toLowerCase() === "y") {
+                            codePaths.push({ name: best.project.name, path: best.project.dir });
+                            projectMappings.push({
+                                name: best.project.name,
+                                dir: best.project.dir,
+                                deployment: best.workload.name,
+                                namespace: best.workload.namespace,
+                                kind: best.workload.kind,
+                            });
+                        }
+                        console.log();
+                    }
+                }
+                // Projects with no match — offer to pick a deployment manually
+                const matchedDirs = new Set(matches.map((m) => m.project.dir));
+                const unmatched = candidates.filter((c) => !matchedDirs.has(c.dir));
+                if (unmatched.length > 0) {
+                    const allWorkloads = [
+                        ...clusterInfo.deployments.map((d) => ({ ...d, kind: "Deployment" })),
+                        ...clusterInfo.statefulsets.map((s) => ({ ...s, kind: "StatefulSet" })),
+                    ];
+                    console.log(chalk.dim("\nProjects without a cluster match:"));
+                    for (const p of unmatched) {
+                        console.log(`\n  ${chalk.bold(p.name + "/")}  (${p.stack.language}/${p.stack.framework})`);
+                        const ans = await ask("  Add to knowledge base? [y/N]");
+                        if (ans.toLowerCase() !== "y")
+                            continue;
+                        codePaths.push({ name: p.name, path: p.dir });
+                        // Let user pick a deployment
+                        console.log(chalk.dim("\n  Pick a deployment (or press Enter to skip mapping):\n"));
+                        allWorkloads.forEach((w, i) => {
+                            console.log(`    ${chalk.cyan(String(i + 1))}. ${w.kind}/${w.namespace}/${w.name}`);
+                        });
+                        const pick = await ask(`\n  Deployment number [skip]:`);
+                        const idx = parseInt(pick, 10) - 1;
+                        if (!isNaN(idx) && idx >= 0 && idx < allWorkloads.length) {
+                            const w = allWorkloads[idx];
+                            projectMappings.push({ name: p.name, dir: p.dir, deployment: w.name, namespace: w.namespace, kind: w.kind });
+                            console.log(chalk.dim(`  Mapped: ${p.name} → ${w.name}`));
+                        }
+                    }
+                    console.log();
+                }
+            }
+        }
+    }
+    else if (mode === "manual") {
+        console.log(chalk.dim("\nEnter one path per line. Empty line to finish.\n"));
+        while (true) {
+            const path = await ask("Code path (empty to finish):");
+            if (!path)
+                break;
+            const name = await ask(`Project name for ${path}:`);
+            codePaths.push({ name: name || path.split("/").pop() || "project", path });
+        }
+    }
+    // Step 4: Scan codebases
+    const projects = codePaths.map(({ name, path }) => ({
+        name,
+        path,
+        stack: detectTechStack(path),
+    }));
+    if (projects.length > 0) {
+        console.log(chalk.bold("\nDetected tech stacks:"));
+        for (const p of projects) {
+            console.log(chalk.green(`  ${p.name}: ${p.stack.language}/${p.stack.framework}`));
+        }
+    }
+    // Step 5: Interview
+    const notes = await runInterview({ cluster: clusterInfo, projects });
+    // Step 6: Write knowledge base
+    const kbDir = join(configDir(), "clusters", contextName);
+    ensureKbDir(kbDir);
+    const clusterMd = formatClusterMarkdown(clusterInfo);
+    writeClusterKb(kbDir, clusterMd);
+    for (const p of projects) {
+        const interviewNotes = Array.from(notes.entries())
+            .filter(([q]) => q.toLowerCase().includes(p.name.toLowerCase()))
+            .map(([q, a]) => `**${q}**\n${a}`)
+            .join("\n\n");
+        const mapping = projectMappings.find((m) => m.name === p.name);
+        const mappingNote = mapping
+            ? `**Deployment:** ${mapping.deployment} (${mapping.namespace})\n**Kind:** ${mapping.kind}`
+            : undefined;
+        const extraNotes = [mappingNote, interviewNotes].filter(Boolean).join("\n\n") || undefined;
+        const projectMd = formatProjectMarkdown(p.name, p.path, p.stack, extraNotes);
+        writeProjectKb(kbDir, p.name, projectMd);
+    }
+    // Save general notes
+    if (notes.size > 0) {
+        const generalNotes = Array.from(notes.entries())
+            .map(([q, a]) => `**${q}**\n${a}`)
+            .join("\n\n");
+        writeProjectKb(kbDir, "_notes", `# Onboarding Notes\n\n${generalNotes}\n`);
+    }
+    // Step 6b: Configure safe actions
+    const currentSafeActions = existingConfig.remediation?.safe_actions ?? DEFAULT_SAFE_ACTIONS;
+    const safeActions = await configureSafeActions(currentSafeActions);
+    // Step 6c: Notification channels
+    const existingChannels = existingConfig.notifications?.channels ?? [];
+    const newChannels = [...existingChannels];
+    console.log(chalk.bold("\nNotifications\n"));
+    if (existingChannels.length > 0) {
+        console.log(chalk.dim(`  ${existingChannels.length} channel(s) already configured.`));
+    }
+    const addNotify = await ask("Set up a notification channel (Slack / Telegram)? [y/N]");
+    if (addNotify.toLowerCase() === "y") {
+        let adding = true;
+        while (adding) {
+            const channel = await interactiveAddChannel();
+            if (channel)
+                newChannels.push(channel);
+            const another = await ask("Add another channel? [y/N]");
+            adding = another.toLowerCase() === "y";
+        }
+    }
+    else {
+        console.log(chalk.dim("  Skipped. Run: kubeagent notify add to set up later."));
+    }
+    // Step 7: Update config
+    const config = loadConfig();
+    config.remediation = { ...config.remediation, safe_actions: safeActions };
+    config.notifications = { ...config.notifications, channels: newChannels };
+    const clusterConfig = {
+        context: contextName,
+        interval: 60,
+        codepaths: codePaths.map((p) => p.path),
+        projects: projectMappings.length > 0 ? projectMappings : undefined,
+    };
+    const existingIdx = config.clusters.findIndex((c) => c.context === contextName);
+    if (existingIdx >= 0) {
+        config.clusters[existingIdx] = clusterConfig;
+    }
+    else {
+        config.clusters.push(clusterConfig);
+    }
+    saveConfig(config);
+    console.log(chalk.green(`\nKnowledge base written to ${kbDir}`));
+    console.log(chalk.green(`Config saved to ${configDir()}/config.yaml`));
+    console.log(chalk.dim("\nRun `kubeagent watch` to start monitoring."));
+}

package/dist/onboard/interview.d.ts

@@ -0,0 +1,12 @@
+import type { ClusterInfo } from "./cluster-scan.js";
+import type { TechStack } from "./code-scan.js";
+interface InterviewContext {
+    cluster: ClusterInfo;
+    projects: Array<{
+        name: string;
+        path: string;
+        stack: TechStack;
+    }>;
+}
+export declare function runInterview(context: InterviewContext): Promise<Map<string, string>>;
+export {};

package/dist/onboard/interview.js

@@ -0,0 +1,71 @@
+import readline from "node:readline";
+import chalk from "chalk";
+import { loadAuth } from "../auth.js";
+import { proxyRequest } from "../proxy-client.js";
+async function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(chalk.cyan(`\n${question}\n> `), (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function createMessage(params) {
+    const auth = loadAuth();
+    if (auth?.apiKey) {
+        const result = await proxyRequest(auth, params);
+        return result;
+    }
+    throw new Error("no_auth");
+}
+export async function runInterview(context) {
+    const notes = new Map();
+    const contextSummary = [
+        `Cluster: ${context.cluster.context}`,
+        `Nodes: ${context.cluster.nodes.length}`,
+        `Namespaces: ${context.cluster.namespaces.join(", ")}`,
+        `Deployments: ${context.cluster.deployments.map((d) => d.name).join(", ")}`,
+        `Projects: ${context.projects.map((p) => `${p.name} (${p.stack.language}/${p.stack.framework})`).join(", ")}`,
+    ].join("\n");
+    let response;
+    try {
+        response = await createMessage({
+            model: "claude-haiku-4-5-20251001",
+            max_tokens: 2000,
+            messages: [
+                {
+                    role: "user",
+                    content: `Given this Kubernetes cluster setup, generate 5-8 short clarifying questions to fill gaps in the knowledge base. Questions should cover: service purposes, constraints, critical vs best-effort services, known quirks, notification preferences. Return one question per line, no numbering.\n\n${contextSummary}`,
+                },
+            ],
+        });
+    }
+    catch (err) {
+        const msg = err.message;
+        if (msg === "no_auth") {
+            console.log(chalk.yellow("Skipping AI interview — run 'kubeagent login' to enable."));
+        }
+        else {
+            console.log(chalk.yellow(`Skipping AI interview — ${msg}`));
+        }
+        return notes;
+    }
+    const questionsText = response.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+    const questions = questionsText
+        .split("\n")
+        .map((q) => q.trim())
+        .filter((q) => q.length > 0 && q.endsWith("?"));
+    console.log(chalk.green("\nI'll ask a few questions to fill gaps in the knowledge base."));
+    console.log(chalk.dim("Press Enter to skip any question.\n"));
+    for (const question of questions) {
+        const answer = await ask(question);
+        if (answer) {
+            notes.set(question, answer);
+        }
+    }
+    return notes;
+}

package/dist/onboard/project-matcher.d.ts

@@ -0,0 +1,25 @@
+import { type TechStack } from "./code-scan.js";
+import type { DeploymentInfo, StatefulSetInfo } from "./cluster-scan.js";
+export interface ProjectCandidate {
+    dir: string;
+    name: string;
+    stack: TechStack;
+    packageName?: string;
+}
+export interface WorkloadRef {
+    name: string;
+    namespace: string;
+    image: string;
+    kind: "Deployment" | "StatefulSet";
+}
+export interface MatchSuggestion {
+    project: ProjectCandidate;
+    workload: WorkloadRef;
+    score: number;
+    reasons: string[];
+}
+/** Scan a parent directory and return all subdirectories that look like code projects. */
+export declare function scanProjectDirectory(parentDir: string): ProjectCandidate[];
+export declare function matchProjectsToWorkloads(projects: ProjectCandidate[], deployments: DeploymentInfo[], statefulsets: StatefulSetInfo[]): MatchSuggestion[];
+/** For each project, return only its best-matching workload (if score ≥ threshold). */
+export declare function bestMatches(suggestions: MatchSuggestion[], threshold?: number): MatchSuggestion[];

package/dist/onboard/project-matcher.js

@@ -0,0 +1,149 @@
+import { readdirSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { detectTechStack } from "./code-scan.js";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/** Strip common deployment suffixes to get the base name. */
+function normalize(s) {
+    return s
+        .toLowerCase()
+        .replace(/[-_](web|api|worker|job|frontend|dashboard|backend|service|app|server|worker\d*)$/, "")
+        .replace(/[-_.]/g, "");
+}
+/** Extract the last path segment from an image, minus the tag. */
+function imageBasename(image) {
+    const withoutTag = image.split(":")[0];
+    return (withoutTag.split("/").pop() ?? withoutTag).toLowerCase();
+}
+/** Read the declared project name from manifest files. */
+function extractPackageName(dir) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            return pkg.name?.toLowerCase();
+        }
+        catch { /* ignore */ }
+    }
+    const goModPath = join(dir, "go.mod");
+    if (existsSync(goModPath)) {
+        const match = readFileSync(goModPath, "utf-8").match(/^module\s+(\S+)/m);
+        if (match)
+            return match[1].split("/").pop()?.toLowerCase();
+    }
+    const composerPath = join(dir, "composer.json");
+    if (existsSync(composerPath)) {
+        try {
+            const c = JSON.parse(readFileSync(composerPath, "utf-8"));
+            return c.name?.split("/").pop()?.toLowerCase();
+        }
+        catch { /* ignore */ }
+    }
+    return undefined;
+}
+// ── Scanning ─────────────────────────────────────────────────────────────────
+/** Scan a parent directory and return all subdirectories that look like code projects. */
+export function scanProjectDirectory(parentDir) {
+    if (!existsSync(parentDir))
+        return [];
+    return readdirSync(parentDir)
+        .filter((entry) => {
+        try {
+            return statSync(join(parentDir, entry)).isDirectory() && !entry.startsWith(".");
+        }
+        catch {
+            return false;
+        }
+    })
+        .filter((entry) => {
+        const d = join(parentDir, entry);
+        // Must have at least one project manifest
+        return (existsSync(join(d, "package.json")) ||
+            existsSync(join(d, "go.mod")) ||
+            existsSync(join(d, "composer.json")) ||
+            existsSync(join(d, "Dockerfile")) ||
+            existsSync(join(d, "pyproject.toml")) ||
+            existsSync(join(d, "Cargo.toml")));
+    })
+        .map((entry) => {
+        const dir = join(parentDir, entry);
+        return {
+            dir,
+            name: basename(dir),
+            stack: detectTechStack(dir),
+            packageName: extractPackageName(dir),
+        };
+    });
+}
+// ── Scoring ──────────────────────────────────────────────────────────────────
+function scoreMatch(project, workload) {
+    const reasons = [];
+    let score = 0;
+    const projName = normalize(project.name);
+    const pkgName = project.packageName ? normalize(project.packageName) : undefined;
+    const wlName = normalize(workload.name);
+    const imgBase = normalize(imageBasename(workload.image));
+    // Exact match on deployment name
+    if (projName === wlName) {
+        score += 60;
+        reasons.push(`Directory name matches deployment name exactly ("${project.name}" = "${workload.name}")`);
+    }
+    else if (wlName.includes(projName) || projName.includes(wlName)) {
+        score += 40;
+        reasons.push(`Directory name "${project.name}" is contained in deployment name "${workload.name}"`);
+    }
+    // Package name vs deployment name
+    if (pkgName) {
+        if (pkgName === wlName) {
+            score += 50;
+            reasons.push(`Package name "${project.packageName}" matches deployment name exactly`);
+        }
+        else if (wlName.includes(pkgName) || pkgName.includes(wlName)) {
+            score += 30;
+            reasons.push(`Package name "${project.packageName}" is contained in deployment name "${workload.name}"`);
+        }
+    }
+    // Image basename vs directory/package name
+    if (imgBase === projName || imgBase === pkgName) {
+        score += 40;
+        reasons.push(`Image basename "${imageBasename(workload.image)}" matches project name`);
+    }
+    else if (projName.includes(imgBase) || imgBase.includes(projName)) {
+        score += 20;
+        reasons.push(`Image basename "${imageBasename(workload.image)}" overlaps with project name "${project.name}"`);
+    }
+    // Cap at 100
+    return { score: Math.min(score, 100), reasons };
+}
+// ── Matching ─────────────────────────────────────────────────────────────────
+export function matchProjectsToWorkloads(projects, deployments, statefulsets) {
+    const workloads = [
+        ...deployments.map((d) => ({ ...d, kind: "Deployment" })),
+        ...statefulsets.map((s) => ({ ...s, kind: "StatefulSet" })),
+    ];
+    const suggestions = [];
+    for (const project of projects) {
+        for (const workload of workloads) {
+            const { score, reasons } = scoreMatch(project, workload);
+            if (score >= 20) {
+                suggestions.push({ project, workload, score, reasons });
+            }
+        }
+    }
+    // Sort: highest score first
+    return suggestions.sort((a, b) => b.score - a.score);
+}
+/** For each project, return only its best-matching workload (if score ≥ threshold). */
+export function bestMatches(suggestions, threshold = 30) {
+    const seen = new Set();
+    const best = [];
+    for (const s of suggestions) {
+        if (s.score < threshold)
+            continue;
+        const key = s.project.dir;
+        if (!seen.has(key)) {
+            seen.add(key);
+            best.push(s);
+        }
+    }
+    return best;
+}

package/dist/orchestrator.d.ts

@@ -0,0 +1,3 @@
+import type { Issue } from "./monitor/types.js";
+import type { KubeAgentConfig } from "./config.js";
+export declare function handleIssues(issues: Issue[], config: KubeAgentConfig, clusterContext?: string, noInteractive?: boolean): Promise<void>;