flowseeker 0.1.7 → 0.1.9

package/dist/extension.js

@@ -64,6 +64,7 @@ const statusBar_1 = require("./runtime/statusBar");
 const chatViewProvider_1 = require("./ui/chatViewProvider");
 const resultTreeProvider_1 = require("./ui/resultTreeProvider");
 const logger_1 = require("./utils/logger");
+const indexWatcher_1 = require("./index/indexWatcher");
 const updateChecker_1 = require("./utils/updateChecker");
 const oauthHandler_1 = require("./auth/oauthHandler");
 const githubAuth_1 = require("./auth/githubAuth");
@@ -146,6 +147,28 @@ async function activate(context) {
     if (mcpProvider) {
         context.subscriptions.push(mcpProvider);
     }
+    // Index watcher: debounce + batch + stale invalidation
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (workspaceFolders && workspaceFolders.length > 0) {
+        const staleState = { stale: false, changedPaths: new Set(), deletedPaths: new Set(), lastInvalidatedAt: undefined };
+        const watcher = (0, indexWatcher_1.createIndexWatcher)({
+            debounceMs: 2000,
+            onFlush: (changed, deleted) => {
+                staleState.stale = true;
+                staleState.lastInvalidatedAt = Date.now();
+                for (const p of changed)
+                    staleState.changedPaths.add(p);
+                for (const p of deleted)
+                    staleState.deletedPaths.add(p);
+            }
+        });
+        const cwd = workspaceFolders[0].uri.fsPath;
+        const fsw = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(cwd, "**/*"));
+        fsw.onDidChange((uri) => (0, indexWatcher_1.onFileChanged)(watcher, vscode.workspace.asRelativePath(uri)));
+        fsw.onDidCreate((uri) => (0, indexWatcher_1.onFileCreated)(watcher, vscode.workspace.asRelativePath(uri)));
+        fsw.onDidDelete((uri) => (0, indexWatcher_1.onFileDeleted)(watcher, vscode.workspace.asRelativePath(uri)));
+        context.subscriptions.push({ dispose: () => { fsw.dispose(); (0, indexWatcher_1.dispose)(watcher); } });
+    }
     (0, logger_1.logInfo)("FlowSeeker commands and result tree registered.");
 }
 function deactivate() { }

package/dist/framework/laravel.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.laravelSlotMapping = void 0;
+exports.detectLaravelFramework = detectLaravelFramework;
+exports.classifyLaravelTask = classifyLaravelTask;
+exports.laravelCategoryRequiredSlots = laravelCategoryRequiredSlots;
+exports.laravelMissingLinkHints = laravelMissingLinkHints;
+exports.applyLaravelTemplate = applyLaravelTemplate;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const laravelSignals = [
+    { path: "artisan", weight: 8, label: "artisan" },
+    { path: "routes/web.php", weight: 6, label: "routes/web.php" },
+    { path: "routes/api.php", weight: 5, label: "routes/api.php" },
+    { path: "app/Http/Controllers", weight: 5, label: "app/Http/Controllers" },
+    { path: "app/Models", weight: 4, label: "app/Models" },
+    { path: "resources/views", weight: 4, label: "resources/views" },
+    { path: "config/app.php", weight: 3, label: "config/app.php" },
+    { path: "bootstrap/app.php", weight: 3, label: "bootstrap/app.php" },
+    { path: "app/Providers", weight: 2, label: "app/Providers" },
+    { path: "app/Http/Middleware", weight: 2, label: "app/Http/Middleware" },
+    { path: "database/migrations", weight: 2, label: "database/migrations" },
+    { path: "app/Console", weight: 2, label: "app/Console" },
+    { path: "vite.config.js", weight: 1, label: "vite.config.js" },
+];
+const minScoreForLaravel = 12;
+async function detectLaravelFramework(rootPath) {
+    const signals = [];
+    let score = 0;
+    for (const signal of laravelSignals) {
+        try {
+            await fs.access(path.join(rootPath, signal.path));
+            score += signal.weight;
+            signals.push(signal.label);
+        }
+        catch {
+            // path doesn't exist
+        }
+    }
+    // Check composer.json for laravel/framework dependency
+    try {
+        const composerRaw = await fs.readFile(path.join(rootPath, "composer.json"), "utf8");
+        const composer = JSON.parse(composerRaw);
+        const deps = { ...(composer.require ?? {}), ...(composer["require-dev"] ?? {}) };
+        if (deps["laravel/framework"]) {
+            score += 10;
+            signals.push("composer:laravel/framework");
+        }
+        const illuminateDeps = Object.keys(deps).filter((k) => k.startsWith("illuminate/"));
+        if (illuminateDeps.length > 0) {
+            score += Math.min(5, illuminateDeps.length);
+            signals.push(`composer:illuminate(${illuminateDeps.length})`);
+        }
+    }
+    catch {
+        // no composer.json
+    }
+    const confidence = Math.min(1, score / 25);
+    return {
+        isLaravel: score >= minScoreForLaravel,
+        confidence,
+        signals,
+    };
+}
+// ── Laravel slot → directory mapping ──────────────────────────────────────────
+exports.laravelSlotMapping = {
+    entry: ["routes/*.php"],
+    handler: ["app/Http/Controllers/**"],
+    domain: ["app/Services/**", "app/Actions/**", "app/Exports/**", "app/Imports/**"],
+    data: ["app/Models/**", "app/Repositories/**", "database/migrations/**"],
+    validation: ["app/Http/Requests/**"],
+    permission: ["app/Policies/**", "app/Http/Middleware/**"],
+    config: ["config/**", ".env", ".env.example"],
+    side_effect: ["app/Jobs/**", "app/Events/**", "app/Listeners/**", "app/Mail/**", "app/Notifications/**"],
+    ui: ["resources/views/**"],
+    tests: ["tests/**"],
+    docs: [],
+    unknown: [],
+};
+function classifyLaravelTask(normalizedTask) {
+    const t = normalizedTask.toLowerCase();
+    if (/\bimport\b/.test(t) || /\bupload\b/.test(t))
+        return "import";
+    if (/\b(export|download|excel|csv|report|pdf)\b/.test(t))
+        return "export_report";
+    if (/\b(auth|login|logout|register|permission|role|policy|guard)\b/.test(t))
+        return "auth_permission";
+    if (/\b(payment|invoice|billing|checkout|refund|gateway)\b/.test(t))
+        return "payment_invoice";
+    if (/\b(email|notification|notify|mail|job|event|listener|dispatch)\b/.test(t))
+        return "notification_email";
+    if (/\b(view|display|page|blade|layout|render|frontend|ui|modal)\b/.test(t))
+        return "view_display";
+    return "generic";
+}
+function laravelCategoryRequiredSlots(category) {
+    const mapping = {
+        export_report: ["entry", "handler", "domain", "data", "side_effect", "tests"],
+        import: ["entry", "handler", "domain", "validation", "data", "tests"],
+        auth_permission: ["entry", "handler", "permission", "domain", "data", "tests"],
+        payment_invoice: ["entry", "handler", "domain", "data", "side_effect", "tests"],
+        notification_email: ["entry", "handler", "side_effect", "data", "tests"],
+        view_display: ["entry", "handler", "ui", "data", "tests"],
+        generic: ["entry", "handler", "domain", "data", "tests"],
+    };
+    return mapping[category] ?? mapping.generic;
+}
+// ── Missing-link hints ────────────────────────────────────────────────────────
+function laravelMissingLinkHints(missingSlots) {
+    const hints = [];
+    for (const slot of missingSlots) {
+        const dirs = exports.laravelSlotMapping[slot];
+        if (dirs && dirs.length > 0) {
+            hints.push(`missing ${slot}: check ${dirs.join(", ")}`);
+        }
+    }
+    return hints;
+}
+async function applyLaravelTemplate(rootPath, normalizedTask, existingRequiredSlots) {
+    const detection = await detectLaravelFramework(rootPath);
+    if (!detection.isLaravel) {
+        return {
+            detected: false,
+            confidence: detection.confidence,
+            category: "generic",
+            suggestedRequiredSlots: [],
+            missingLinkHints: [],
+        };
+    }
+    const category = classifyLaravelTask(normalizedTask);
+    const templateSlots = laravelCategoryRequiredSlots(category);
+    const existing = new Set(existingRequiredSlots);
+    const suggested = templateSlots.filter((s) => !existing.has(s));
+    const missing = templateSlots.filter((s) => !existing.has(s));
+    const hints = laravelMissingLinkHints(missing);
+    return {
+        detected: true,
+        confidence: detection.confidence,
+        category,
+        suggestedRequiredSlots: suggested,
+        missingLinkHints: hints,
+    };
+}
+//# sourceMappingURL=laravel.js.map