@kentwynn/kgraph 0.2.32 → 0.2.33

package/dist/cli/commands/init.js

@@ -1,4 +1,4 @@
-import { loadConfig, writeDefaultConfig } from '../../config/config.js';
+import { loadConfig, saveConfig, writeDefaultConfig, } from '../../config/config.js';
 import { normalizeIntegrationNames } from '../../integrations/integration-registry.js';
 import { addIntegrations } from '../../integrations/integration-store.js';
 import { ensureKnowledgeStore } from '../../knowledge/atom-store.js';
@@ -6,9 +6,10 @@ import { scanRepository } from '../../scanner/repo-scanner.js';
 import { ensureWorkspace } from '../../storage/kgraph-paths.js';
 import { readMaps, writeMaps } from '../../storage/map-store.js';
 import { KGraphError, runCommand } from '../errors.js';
-import { promptForInitIntegrations, shouldPromptForInitIntegrations, } from '../init-prompt.js';
+import { promptForInitIntegrations, promptScopeConfirmation, promptWorkspaceSetup, shouldPromptForInitIntegrations, } from '../init-prompt.js';
 import { detectMachineIntegrationRecommendations, recommendedIntegrationsForInit, } from '../init-recommendations.js';
 import { renderInitSummary } from '../init-summary.js';
+import { countScopeFiles, detectWorkspaces } from '../workspace-detection.js';
 export function registerInitCommand(program) {
     program
         .command('init')
@@ -33,6 +34,26 @@ export function registerInitCommand(program) {
             console.log(`Configured integrations: ${changed.map((item) => `${item.name}:${item.mode}`).join(', ')}`);
         }
         let config = await loadConfig(workspace);
+        // Workspace detection — only for fresh init, non-destructive
+        const workspaceInfo = await detectWorkspaces(workspace.rootPath);
+        if (workspaceInfo && Object.keys(config.domainHints).length === 0) {
+            const result = await promptWorkspaceSetup(workspaceInfo);
+            if (result.applyDomains && result.domainHints) {
+                config = { ...config, domainHints: result.domainHints };
+                await saveConfig(workspace, config);
+            }
+        }
+        // Pre-scan scope check — fast file count before heavy scan
+        const fileCount = await countScopeFiles(workspace.rootPath, config);
+        const scopeResult = await promptScopeConfirmation(fileCount);
+        if (!scopeResult.proceed) {
+            console.log('Init cancelled. Edit .kgraph/config.yaml to adjust scope, then run `kgraph init` again.');
+            return;
+        }
+        if (scopeResult.narrowedInclude) {
+            config = { ...config, include: scopeResult.narrowedInclude };
+            await saveConfig(workspace, config);
+        }
         const previousMaps = await readMaps(workspace);
         const result = await scanRepository(workspace.rootPath, config, {
             files: previousMaps.fileMap.files,

package/dist/cli/init-prompt.d.ts

@@ -1,8 +1,27 @@
-import type { IntegrationConfig, IntegrationName } from '../types/config.js';
+import type { DomainHint, IntegrationConfig, IntegrationName } from '../types/config.js';
 import type { InitIntegrationRecommendation } from './init-recommendations.js';
+import type { WorkspaceInfo } from './workspace-detection.js';
 export declare function shouldPromptForInitIntegrations(options: {
     explicitIntegrationsRequested: boolean;
     configuredIntegrations: Pick<IntegrationConfig, 'name'>[];
     interactive?: boolean;
 }): boolean;
 export declare function promptForInitIntegrations(recommendations: InitIntegrationRecommendation[]): Promise<IntegrationName[]>;
+export interface ScopeConfirmResult {
+    proceed: boolean;
+    narrowedInclude?: string[];
+}
+/**
+ * If file count exceeds threshold, ask user whether to proceed or narrow scope.
+ * For small repos, returns { proceed: true } without prompting.
+ */
+export declare function promptScopeConfirmation(fileCount: number, threshold?: number): Promise<ScopeConfirmResult>;
+export interface WorkspacePromptResult {
+    applyDomains: boolean;
+    domainHints?: Record<string, DomainHint>;
+}
+/**
+ * If a monorepo workspace is detected, offer to configure domain hints.
+ * For simple projects (no workspace detected), skips silently.
+ */
+export declare function promptWorkspaceSetup(info: WorkspaceInfo): Promise<WorkspacePromptResult>;

package/dist/cli/init-prompt.js

@@ -59,3 +59,60 @@ export async function promptForInitIntegrations(recommendations) {
 function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
 }
+/**
+ * If file count exceeds threshold, ask user whether to proceed or narrow scope.
+ * For small repos, returns { proceed: true } without prompting.
+ */
+export async function promptScopeConfirmation(fileCount, threshold = 500) {
+    if (fileCount <= threshold || !isInteractiveTerminal()) {
+        return { proceed: true };
+    }
+    const action = await clack.select({
+        message: `Found ${fileCount.toLocaleString()} files in scope`,
+        options: [
+            { value: 'proceed', label: 'Continue with all files' },
+            {
+                value: 'narrow',
+                label: 'Narrow to src/ only',
+                hint: 'include: ["src/**"]',
+            },
+            { value: 'cancel', label: "Cancel — I'll edit config.yaml manually" },
+        ],
+    });
+    if (clack.isCancel(action) || action === 'cancel') {
+        return { proceed: false };
+    }
+    if (action === 'narrow') {
+        return { proceed: true, narrowedInclude: ['src/**'] };
+    }
+    return { proceed: true };
+}
+/**
+ * If a monorepo workspace is detected, offer to configure domain hints.
+ * For simple projects (no workspace detected), skips silently.
+ */
+export async function promptWorkspaceSetup(info) {
+    if (!isInteractiveTerminal()) {
+        return { applyDomains: false };
+    }
+    const packageNames = info.packages.map((p) => p.name).join(', ');
+    const action = await clack.select({
+        message: `Detected ${info.tool} workspace (${info.packages.length} packages: ${packageNames})`,
+        options: [
+            {
+                value: 'apply',
+                label: 'Configure domain hints from packages',
+                hint: 'context packs will prefer the active package',
+            },
+            { value: 'skip', label: 'Skip — scan everything flat' },
+        ],
+    });
+    if (clack.isCancel(action) || action === 'skip') {
+        return { applyDomains: false };
+    }
+    const hints = {};
+    for (const pkg of info.packages) {
+        hints[pkg.name] = { paths: [pkg.path + '/**'] };
+    }
+    return { applyDomains: true, domainHints: hints };
+}

package/dist/cli/workspace-detection.d.ts

@@ -0,0 +1,23 @@
+import type { DomainHint, KGraphConfig } from '../types/config.js';
+export interface WorkspaceInfo {
+    tool: string;
+    packages: WorkspacePackage[];
+}
+export interface WorkspacePackage {
+    name: string;
+    path: string;
+}
+/**
+ * Detect monorepo workspace tools and their packages.
+ * Returns null for simple single-package projects.
+ */
+export declare function detectWorkspaces(rootPath: string): Promise<WorkspaceInfo | null>;
+/**
+ * Convert detected workspace packages into domainHints.
+ */
+export declare function workspacesToDomainHints(info: WorkspaceInfo): Record<string, DomainHint>;
+/**
+ * Quick file count using fast-glob (no content read).
+ * Used to warn about large scopes before a full scan.
+ */
+export declare function countScopeFiles(rootPath: string, config: KGraphConfig): Promise<number>;

package/dist/cli/workspace-detection.js

@@ -0,0 +1,169 @@
+import fg from 'fast-glob';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { buildFastGlobIgnore, readGitignorePatterns, } from '../scanner/file-classifier.js';
+import { pathExists } from '../storage/kgraph-paths.js';
+/**
+ * Detect monorepo workspace tools and their packages.
+ * Returns null for simple single-package projects.
+ */
+export async function detectWorkspaces(rootPath) {
+    // pnpm
+    const pnpmPath = path.join(rootPath, 'pnpm-workspace.yaml');
+    if (await pathExists(pnpmPath)) {
+        const packages = await resolvePnpmPackages(rootPath, pnpmPath);
+        if (packages.length > 1)
+            return { tool: 'pnpm', packages };
+    }
+    // nx
+    const nxPath = path.join(rootPath, 'nx.json');
+    if (await pathExists(nxPath)) {
+        const packages = await resolveNxPackages(rootPath);
+        if (packages.length > 1)
+            return { tool: 'nx', packages };
+    }
+    // lerna
+    const lernaPath = path.join(rootPath, 'lerna.json');
+    if (await pathExists(lernaPath)) {
+        const packages = await resolveLernaPackages(rootPath, lernaPath);
+        if (packages.length > 1)
+            return { tool: 'lerna', packages };
+    }
+    // rush
+    const rushPath = path.join(rootPath, 'rush.json');
+    if (await pathExists(rushPath)) {
+        const packages = await resolveRushPackages(rootPath, rushPath);
+        if (packages.length > 1)
+            return { tool: 'rush', packages };
+    }
+    // npm/yarn workspaces (package.json)
+    const pkgPath = path.join(rootPath, 'package.json');
+    if (await pathExists(pkgPath)) {
+        const packages = await resolveNpmWorkspaces(rootPath, pkgPath);
+        if (packages.length > 1)
+            return { tool: 'npm', packages };
+    }
+    return null;
+}
+/**
+ * Convert detected workspace packages into domainHints.
+ */
+export function workspacesToDomainHints(info) {
+    const hints = {};
+    for (const pkg of info.packages) {
+        hints[pkg.name] = { paths: [pkg.path + '/**'] };
+    }
+    return hints;
+}
+/**
+ * Quick file count using fast-glob (no content read).
+ * Used to warn about large scopes before a full scan.
+ */
+export async function countScopeFiles(rootPath, config) {
+    const gitignorePatterns = await readGitignorePatterns(rootPath);
+    const allExcludes = [...config.exclude, ...gitignorePatterns];
+    const entries = await fg(config.include, {
+        cwd: rootPath,
+        dot: true,
+        onlyFiles: true,
+        unique: true,
+        ignore: buildFastGlobIgnore(allExcludes),
+        stats: false,
+    });
+    return entries.length;
+}
+// --- Resolvers ---
+async function resolvePnpmPackages(rootPath, filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        // Simple YAML parsing for packages: array
+        const lines = content.split(/\r?\n/);
+        const globs = [];
+        let inPackages = false;
+        for (const line of lines) {
+            if (/^packages:/i.test(line.trim())) {
+                inPackages = true;
+                continue;
+            }
+            if (inPackages) {
+                const match = line.match(/^\s+-\s+['"]?([^'"]+)['"]?\s*$/);
+                if (match) {
+                    globs.push(match[1]);
+                }
+                else if (/^\S/.test(line) && line.trim().length > 0) {
+                    break;
+                }
+            }
+        }
+        if (globs.length === 0)
+            globs.push('packages/*');
+        return await resolvePackageGlobs(rootPath, globs);
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveNxPackages(rootPath) {
+    // Nx projects live in common dirs
+    const candidates = ['apps/*', 'libs/*', 'packages/*'];
+    return await resolvePackageGlobs(rootPath, candidates);
+}
+async function resolveLernaPackages(rootPath, filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        const globs = Array.isArray(parsed.packages)
+            ? parsed.packages
+            : ['packages/*'];
+        return await resolvePackageGlobs(rootPath, globs);
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveRushPackages(rootPath, filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (!Array.isArray(parsed.projects))
+            return [];
+        return parsed.projects
+            .filter((p) => p.projectFolder)
+            .map((p) => ({
+            name: p.packageName || path.basename(p.projectFolder),
+            path: p.projectFolder,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveNpmWorkspaces(rootPath, filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        const workspaces = parsed.workspaces;
+        if (!workspaces)
+            return [];
+        const globs = Array.isArray(workspaces)
+            ? workspaces
+            : (workspaces.packages ?? []);
+        if (globs.length === 0)
+            return [];
+        return await resolvePackageGlobs(rootPath, globs);
+    }
+    catch {
+        return [];
+    }
+}
+async function resolvePackageGlobs(rootPath, globs) {
+    const dirs = await fg(globs, {
+        cwd: rootPath,
+        onlyDirectories: true,
+        deep: 1,
+    });
+    return dirs.sort().map((dir) => ({
+        name: path.basename(dir),
+        path: dir.split(path.sep).join('/'),
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {