blokctl 0.2.0

package/dist/commands/search/docs.js

@@ -0,0 +1,179 @@
+import { Command } from "../../services/commander.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+import color from "picocolors";
+import pluralize from "pluralize";
+import { Indexer } from "./indexer.js";
+export class SearchService {
+    MAX_TOKENS = 3000;
+    indexer = new Indexer();
+    extractKeywords(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, "")
+            .split(/\s+/)
+            .map((w) => pluralize.singular(w))
+            .filter(Boolean);
+    }
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    async getRankedFilesFromIndex(index, question) {
+        const keywords = this.extractKeywords(question);
+        const fileScores = {};
+        for (const word of keywords) {
+            let matches = index.words.filter((w) => w.value === word);
+            if (matches.length === 0 && word.length > 3) {
+                matches = index.words.filter((w) => w.value.includes(word) || word.includes(w.value));
+            }
+            if (matches.length === 0)
+                continue;
+            for (const match of matches) {
+                for (const fileEntry of match.files) {
+                    const matchScore = match.value === word ? fileEntry.score : fileEntry.score * 0.5;
+                    fileScores[fileEntry.path] = (fileScores[fileEntry.path] || 0) + matchScore;
+                }
+            }
+        }
+        return Object.entries(fileScores)
+            .map(([path, score]) => ({ path, score }))
+            .sort((a, b) => b.score - a.score);
+    }
+    async getLimitedContext(files) {
+        let total = 0;
+        const chunks = [];
+        for (const { path: file } of files) {
+            try {
+                const content = await fs.readFile(file, "utf-8");
+                let formattedContent;
+                if (file.endsWith(".json")) {
+                    const jsonContent = JSON.parse(content);
+                    formattedContent = [
+                        `# ${jsonContent.name || path.basename(file)}`,
+                        `Description: ${jsonContent.description || "No description"}`,
+                        jsonContent.type ? `Type: ${jsonContent.type}` : "",
+                        "",
+                        "Configuration:",
+                        "```json",
+                        JSON.stringify(jsonContent, null, 2),
+                        "```",
+                    ]
+                        .filter(Boolean)
+                        .join("\n");
+                }
+                else {
+                    formattedContent = content;
+                }
+                const tokens = this.estimateTokens(formattedContent);
+                if (total + tokens > this.MAX_TOKENS)
+                    break;
+                total += tokens;
+                chunks.push(`---\n# File: ${path.basename(file)}\n${formattedContent}`);
+            }
+            catch (error) {
+                console.log(color.red(`Error reading file: ${file}`));
+            }
+        }
+        return chunks.join("\n\n");
+    }
+    async ask(question, options = {}) {
+        const index = await this.indexer.getIndex(options.noCache);
+        const ranked = await this.getRankedFilesFromIndex(index, question);
+        if (ranked.length === 0) {
+            console.log(color.yellow("No relevant files found for the search terms"));
+            return;
+        }
+        const context = await this.getLimitedContext(ranked);
+        if (!context) {
+            console.log(color.yellow("No content could be read from the files"));
+            return;
+        }
+        try {
+            const openai = createOpenAI({
+                compatibility: "strict",
+                apiKey: process.env.OPENAI_API_KEY,
+            });
+            console.log(color.cyan("\nAnalyzing documentation..."));
+            const response = await generateText({
+                model: openai("gpt-4"),
+                system: `You are a helpful assistant that answers questions based on the documentation provided.
+Your responses should be clear, concise, and directly based on the content in the documentation.
+If the documentation includes code examples or configuration, include relevant parts in your response.
+Format your response using markdown for better readability.`,
+                prompt: `Context:\n${context}\n\nQuestion: ${question}`,
+                temperature: 0.2,
+            });
+            console.log(`\n${color.dim("Sources used:")}`);
+            for (const { path: file, score } of ranked) {
+                console.log(color.dim(`- ${path.basename(file)} (relevance: ${score.toFixed(2)})`));
+            }
+            console.log();
+            console.log(color.green("Answer:"));
+            console.log("─".repeat(process.stdout.columns || 80));
+            console.log(this.formatResponseText(response.text));
+            console.log("─".repeat(process.stdout.columns || 80));
+            console.log();
+        }
+        catch (error) {
+            console.log(color.red("\nError generating response:"));
+            console.log(color.red(error instanceof Error ? error.message : "Unknown error"));
+        }
+    }
+    formatResponseText(text) {
+        return text
+            .split("\n")
+            .map((line) => {
+            if (line.startsWith("```")) {
+                return color.dim("─".repeat(process.stdout.columns || 80));
+            }
+            if (line.includes("`")) {
+                return line.replace(/`([^`]+)`/g, (_, code) => color.cyan(code));
+            }
+            if (line.includes("**")) {
+                return line.replace(/\*\*([^*]+)\*\*/g, (_, text) => color.bold(text));
+            }
+            if (line.startsWith("#")) {
+                const headerMatch = line.match(/^#+/);
+                if (headerMatch) {
+                    const title = line.replace(/^#+\s*/, "");
+                    return color.bold(color.blue(title));
+                }
+            }
+            if (line.match(/^[-*]\s/)) {
+                return `${color.dim("•")} ${line.replace(/^[-*]\s/, "")}`;
+            }
+            if (line.match(/^\d+\.\s/)) {
+                const numMatch = line.match(/^\d+/);
+                if (numMatch) {
+                    return `${color.dim(`${numMatch[0]}.`)}${line.replace(/^\d+\.\s/, " ")}`;
+                }
+            }
+            if (line.match(/^\s*["{[]/) && line.match(/[}"\]]$/)) {
+                try {
+                    return color.gray(line);
+                }
+                catch {
+                    return line;
+                }
+            }
+            return line;
+        })
+            .join("\n");
+    }
+}
+export default new Command()
+    .command("docs")
+    .description("This command allows you to search for information in the documentation.")
+    .option("-q, --question <value>", "Question to search for")
+    .option("--no-cache", "Force rebuild of search index")
+    .action(async (options) => {
+    const question = options.question;
+    if (!question) {
+        console.error("Question is required");
+        process.exit(1);
+    }
+    const searchService = new SearchService();
+    await searchService.ask(question, { noCache: !options.cache });
+});

package/dist/commands/search/index.d.ts

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

package/dist/commands/search/index.js

@@ -0,0 +1,5 @@
+import { program } from "../../services/commander.js";
+import docs from "./docs.js";
+import node from "./nodes.js";
+import workflow from "./workflow.js";
+program.command("search").description("Search commands").addCommand(node).addCommand(workflow).addCommand(docs);

package/dist/commands/search/indexer.d.ts

@@ -0,0 +1,10 @@
+export declare class Indexer {
+    private readonly INDEX_PATH;
+    private readonly ONE_DAY_MS;
+    private extractKeywords;
+    private indexDirectory;
+    private indexJsonDirectory;
+    private mergeWordMaps;
+    private buildIndex;
+    getIndex(forceRebuild?: boolean): Promise<ReturnType<typeof this.buildIndex>>;
+}

package/dist/commands/search/indexer.js

@@ -0,0 +1,265 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import fg from "fast-glob";
+import color from "picocolors";
+import pluralize from "pluralize";
+export class Indexer {
+    INDEX_PATH = `${os.homedir()}/.blok/search_indexes.json`;
+    ONE_DAY_MS = 24 * 60 * 60 * 1000;
+    extractKeywords(text) {
+        const stopWords = new Set([
+            "a",
+            "an",
+            "the",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+            "of",
+            "with",
+            "by",
+            "el",
+            "la",
+            "los",
+            "las",
+            "un",
+            "una",
+            "unos",
+            "unas",
+            "de",
+            "del",
+            "is",
+            "are",
+            "was",
+            "were",
+            "be",
+            "been",
+            "being",
+            "es",
+            "son",
+            "está",
+            "están",
+            "this",
+            "that",
+            "these",
+            "those",
+            "here",
+            "there",
+            "este",
+            "esta",
+            "estos",
+            "estas",
+            "aquí",
+            "allí",
+            "function",
+            "class",
+            "const",
+            "let",
+            "var",
+            "return",
+            "import",
+            "export",
+        ]);
+        const words = text
+            .toLowerCase()
+            .replace(/```[\s\S]*?```/g, " ")
+            .replace(/`.*?`/g, " ")
+            .replace(/\[.*?\]/g, " ")
+            .replace(/\(.*?\)/g, " ")
+            .replace(/[#*_]/g, " ")
+            .replace(/[^a-z\s]/g, " ")
+            .split(/\s+/)
+            .filter((word) => word && word.length > 2 && !stopWords.has(word))
+            .map((word) => pluralize.singular(word));
+        return [...new Set(words)];
+    }
+    async indexDirectory(dirPath, sourceLabel) {
+        const wordMap = {};
+        try {
+            await fs.access(dirPath);
+            const files = await fg(["**/*.md", "**/README.md", "**/readme.md"], {
+                cwd: dirPath,
+                absolute: true,
+                onlyFiles: true,
+                followSymbolicLinks: false,
+                ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+            });
+            for (const file of files) {
+                try {
+                    const raw = await fs.readFile(file, "utf-8");
+                    const words = this.extractKeywords(raw);
+                    const fileWordMap = {};
+                    const wordFreq = {};
+                    for (const word of words) {
+                        wordFreq[word] = (wordFreq[word] || 0) + 1;
+                    }
+                    for (const [word, freq] of Object.entries(wordFreq)) {
+                        const score = freq * Math.sqrt(word.length);
+                        const entry = { path: file, score, source: sourceLabel };
+                        if (!fileWordMap[word]) {
+                            fileWordMap[word] = [];
+                        }
+                        else if (!Array.isArray(fileWordMap[word])) {
+                            fileWordMap[word] = [];
+                        }
+                        fileWordMap[word].push(entry);
+                    }
+                    for (const [word, entries] of Object.entries(fileWordMap)) {
+                        if (!wordMap[word]) {
+                            wordMap[word] = [];
+                        }
+                        else if (!Array.isArray(wordMap[word])) {
+                            wordMap[word] = [];
+                        }
+                        wordMap[word].push(...entries);
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        catch {
+        }
+        return wordMap;
+    }
+    async indexJsonDirectory(dirPath, sourceLabel) {
+        const wordMap = {};
+        try {
+            await fs.access(dirPath);
+            const files = await fg(["**/*.json"], {
+                cwd: dirPath,
+                absolute: true,
+                onlyFiles: true,
+                followSymbolicLinks: false,
+                ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+            });
+            for (const file of files) {
+                try {
+                    const raw = await fs.readFile(file, "utf-8");
+                    const jsonContent = JSON.parse(raw);
+                    const importantFields = {
+                        name: 3,
+                        description: 2,
+                        type: 1.5,
+                    };
+                    const processField = (field, content, weight) => {
+                        if (typeof content === "string") {
+                            const words = this.extractKeywords(content);
+                            for (const word of words) {
+                                if (!wordMap[word])
+                                    wordMap[word] = [];
+                                wordMap[word].push({
+                                    path: file,
+                                    score: weight * Math.sqrt(word.length),
+                                    source: sourceLabel,
+                                });
+                            }
+                        }
+                    };
+                    for (const [field, weight] of Object.entries(importantFields)) {
+                        const content = jsonContent[field];
+                        if (content && typeof content === "string") {
+                            processField(field, content, weight);
+                        }
+                    }
+                    const textContent = JSON.stringify(jsonContent, null, 2);
+                    const words = this.extractKeywords(textContent);
+                    const fileWordMap = {};
+                    const wordFreq = {};
+                    for (const word of words) {
+                        wordFreq[word] = (wordFreq[word] || 0) + 1;
+                    }
+                    for (const [word, freq] of Object.entries(wordFreq)) {
+                        const score = freq * Math.sqrt(word.length);
+                        const entry = { path: file, score, source: sourceLabel };
+                        if (!fileWordMap[word]) {
+                            fileWordMap[word] = [];
+                        }
+                        else if (!Array.isArray(fileWordMap[word])) {
+                            fileWordMap[word] = [];
+                        }
+                        fileWordMap[word].push(entry);
+                    }
+                    for (const [word, entries] of Object.entries(fileWordMap)) {
+                        if (!wordMap[word]) {
+                            wordMap[word] = [];
+                        }
+                        else if (!Array.isArray(wordMap[word])) {
+                            wordMap[word] = [];
+                        }
+                        wordMap[word].push(...entries);
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        catch {
+        }
+        return wordMap;
+    }
+    mergeWordMaps(...maps) {
+        const combined = {};
+        for (const map of maps) {
+            for (const [word, entries] of Object.entries(map)) {
+                if (!combined[word]) {
+                    combined[word] = [];
+                }
+                else if (!Array.isArray(combined[word])) {
+                    combined[word] = [];
+                }
+                combined[word].push(...entries);
+            }
+        }
+        return combined;
+    }
+    async buildIndex() {
+        const HOME_DIR = os.homedir();
+        const NANOCTL_DIR = path.join(HOME_DIR, ".blok");
+        const GITHUB_REPO_LOCAL = path.join(NANOCTL_DIR, "blok");
+        const homeDocsPath = path.join(GITHUB_REPO_LOCAL, "docs");
+        const userNodesPath = path.resolve(process.cwd(), "src/nodes");
+        const notesPath = path.resolve(process.cwd(), "notes");
+        const jsonPath = path.resolve(process.cwd(), "workflows/json");
+        await fs.mkdir(NANOCTL_DIR, { recursive: true });
+        const docsMap = await this.indexDirectory(homeDocsPath, "docs");
+        const userMap = await this.indexDirectory(userNodesPath, "user-nodes");
+        const notesMap = await this.indexDirectory(notesPath, "notes");
+        const jsonMap = await this.indexJsonDirectory(jsonPath, "json-examples");
+        const combinedMap = this.mergeWordMaps(docsMap, userMap, notesMap, jsonMap);
+        const sortedWords = Object.entries(combinedMap)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([value, files]) => ({
+            value,
+            files,
+        }));
+        const index = {
+            words: sortedWords,
+            lastIndexDateTime: new Date().toISOString(),
+        };
+        await fs.writeFile(this.INDEX_PATH, JSON.stringify(index, null, 2));
+        return index;
+    }
+    async getIndex(forceRebuild = false) {
+        try {
+            if (!forceRebuild) {
+                const stat = await fs.stat(this.INDEX_PATH);
+                const age = Date.now() - new Date(stat.mtime).getTime();
+                if (age <= this.ONE_DAY_MS) {
+                    const raw = await fs.readFile(this.INDEX_PATH, "utf-8");
+                    return JSON.parse(raw);
+                }
+                console.log(color.yellow("Index outdated. Rebuilding..."));
+            }
+            else {
+                console.log(color.yellow("Force rebuilding index..."));
+            }
+        }
+        catch {
+            console.log(color.yellow("No index found. Creating new one..."));
+        }
+        return await this.buildIndex();
+    }
+}

package/dist/commands/search/nodes.d.ts

@@ -0,0 +1,4 @@
+import { Command, type OptionValues } from "../../services/commander.js";
+export declare function search(opts: OptionValues): Promise<void>;
+declare const _default: Command;
+export default _default;

package/dist/commands/search/nodes.js

@@ -0,0 +1,101 @@
+import * as p from "@clack/prompts";
+import { Command, trackCommandExecution } from "../../services/commander.js";
+import { BLOK_URL } from "../../services/constants.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+import { isNonInteractive } from "../../services/non-interactive.js";
+import { install } from "../install/node.js";
+async function searchPkg(opts) {
+    const response = await fetch(`${BLOK_URL}/package-list?searchTerm=${opts.node}&format=${opts.format}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(response.statusText);
+    const pkgList = await response.json();
+    return pkgList.packages;
+}
+export async function search(opts) {
+    const token = tokenManager.getToken();
+    const logger = p.spinner();
+    try {
+        if (!token)
+            throw new Error("Token is required.");
+        if (!opts.node)
+            throw new Error("Node name is required.");
+        opts.token = token;
+        logger.start("Searching for packages...");
+        const pkgList = await searchPkg(opts);
+        if (pkgList.length === 0) {
+            throw new Error("No packages found.");
+        }
+        if (opts.list || (isNonInteractive() && !opts.install)) {
+            logger.stop(`Found ${pkgList.length} package(s):`);
+            for (const pkg of pkgList) {
+                p.log.info(pkg.package);
+            }
+            return;
+        }
+        if (opts.install) {
+            const pkgInfo = pkgList.find((pkg) => pkg.package === opts.install);
+            if (!pkgInfo)
+                throw new Error(`Package "${opts.install}" not found in search results.`);
+            logger.stop(`Starting installation of ${pkgInfo.package}...`);
+            await trackCommandExecution({
+                command: "install",
+                args: opts,
+                execution: async () => {
+                    opts.node = pkgInfo.package;
+                    if (!opts.directory)
+                        opts.directory = process.cwd();
+                    await install(opts);
+                },
+            });
+            return;
+        }
+        const selectedPkg = await p.select({
+            message: "Select a package to install",
+            options: pkgList.map((pkg) => ({
+                label: pkg.package,
+                value: pkg,
+            })),
+        });
+        if (!selectedPkg || typeof selectedPkg === "symbol")
+            throw new Error("No package selected.");
+        const pkgInfo = pkgList.find((pkg) => pkg.package === selectedPkg.package);
+        if (!pkgInfo)
+            throw new Error("Selected package not found.");
+        logger.stop(`Starting installation of ${pkgInfo.package}...`);
+        await trackCommandExecution({
+            command: "install",
+            args: opts,
+            execution: async () => {
+                opts.node = pkgInfo.package;
+                if (!opts.directory)
+                    opts.directory = process.cwd();
+                await install(opts);
+            },
+        });
+    }
+    catch (error) {
+        logger.error(error.message);
+    }
+}
+export default new Command()
+    .command("node")
+    .description("Publish a node to the registry")
+    .option("-f, --format <value>", "Package format", "npm")
+    .option("-i, --install <value>", "Package name to auto-install (skip select prompt)")
+    .option("-l, --list", "List results without prompting to install")
+    .argument("<node>", "Node name")
+    .action(async (node, options) => {
+    await trackCommandExecution({
+        command: "search node",
+        args: options,
+        execution: async () => {
+            options.node = node;
+            await search(options);
+        },
+    });
+});

package/dist/commands/search/workflow.d.ts

@@ -0,0 +1,4 @@
+import { Command, type OptionValues } from "../../services/commander.js";
+export declare function search(opts: OptionValues): Promise<void>;
+declare const _default: Command;
+export default _default;

package/dist/commands/search/workflow.js

@@ -0,0 +1,100 @@
+import * as p from "@clack/prompts";
+import { Command, trackCommandExecution } from "../../services/commander.js";
+import { BLOK_URL } from "../../services/constants.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+import { isNonInteractive } from "../../services/non-interactive.js";
+import { install } from "../install/workflow.js";
+async function searchWorkflow(opts) {
+    const response = await fetch(`${BLOK_URL}/published-workflow?workflow_name=${opts.workflow}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(response.statusText);
+    const searchs = await response.json();
+    return searchs.documents;
+}
+export async function search(opts) {
+    const token = tokenManager.getToken();
+    const logger = p.spinner();
+    try {
+        if (!token)
+            throw new Error("Token is required.");
+        if (!opts.workflow)
+            throw new Error("Workflow argument is required.");
+        opts.token = token;
+        logger.start("Searching for workflow...");
+        const searchs = await searchWorkflow(opts);
+        if (searchs.length === 0) {
+            throw new Error("No workflow found.");
+        }
+        if (opts.list || (isNonInteractive() && !opts.install)) {
+            logger.stop(`Found ${searchs.length} workflow(s):`);
+            for (const data of searchs) {
+                p.log.info(`${data.id} (${data.workflow.name}:${data.workflow.version} - ${data.workflow.description})`);
+            }
+            return;
+        }
+        if (opts.install) {
+            const workflowInfo = searchs.find((workflow) => workflow.id === opts.install);
+            if (!workflowInfo)
+                throw new Error(`Workflow "${opts.install}" not found in search results.`);
+            logger.stop(`Starting installation of ${workflowInfo.id}...`);
+            await trackCommandExecution({
+                command: "install",
+                args: opts,
+                execution: async () => {
+                    opts.workflow = workflowInfo.id;
+                    if (!opts.directory)
+                        opts.directory = process.cwd();
+                    await install(opts);
+                },
+            });
+            return;
+        }
+        const selectedWorkflow = await p.select({
+            message: "Select a workflow to install",
+            options: searchs.map((data) => ({
+                label: `${data.id} (${data.workflow.name}:${data.workflow.version} - ${data.workflow.description})`,
+                value: data,
+            })),
+        });
+        if (!selectedWorkflow || typeof selectedWorkflow === "symbol")
+            throw new Error("No workflow selected.");
+        const workflowInfo = searchs.find((workflow) => workflow.id === selectedWorkflow.id);
+        if (!workflowInfo)
+            throw new Error("Selected workflow not found.");
+        logger.stop(`Starting installation of ${workflowInfo.id}...`);
+        await trackCommandExecution({
+            command: "install",
+            args: opts,
+            execution: async () => {
+                opts.workflow = workflowInfo.id;
+                if (!opts.directory)
+                    opts.directory = process.cwd();
+                await install(opts);
+            },
+        });
+    }
+    catch (error) {
+        logger.error(error.message);
+    }
+}
+export default new Command()
+    .command("workflow")
+    .description("Search for a workflow")
+    .option("-i, --install <value>", "Workflow ID to auto-install (skip select prompt)")
+    .option("-l, --list", "List results without prompting to install")
+    .argument("<workflow>", "Workflow hints")
+    .action(async (workflow, options) => {
+    await trackCommandExecution({
+        command: "search workflow",
+        args: options,
+        execution: async () => {
+            options.workflow = workflow;
+            await search(options);
+        },
+    });
+});

package/dist/commands/trace/index.d.ts

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