@chronova/wiki-agent 1.1.4

package/dist/tools.js

@@ -0,0 +1,471 @@
+import { readFile, writeFile, readdir, mkdir } from "node:fs/promises";
+import { exec } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+const MAX_READ_LENGTH = 50_000;
+const MAX_TOOL_RESULT_LENGTH = 10_000;
+function truncateResult(result) {
+    if (result.length <= MAX_TOOL_RESULT_LENGTH) {
+        return result;
+    }
+    return result.slice(0, MAX_TOOL_RESULT_LENGTH) + "\n... (truncated)";
+}
+/**
+ * Resolves a path relative to the project root and validates it stays within
+ * the `.wiki/` directory. Throws on escape attempts.
+ */
+function resolveWikiPath(relativePath, projectRoot) {
+    const wikiRoot = path.resolve(projectRoot, ".wiki");
+    const resolved = path.resolve(projectRoot, relativePath);
+    if (!resolved.startsWith(wikiRoot + path.sep) && resolved !== wikiRoot) {
+        throw new Error(`Path ${relativePath} resolves outside .wiki/. Only files under .wiki/ can be written.`);
+    }
+    return resolved;
+}
+/**
+ * Resolves a path relative to the project root (for read-only operations).
+ */
+function resolveProjectPath(relativePath, projectRoot) {
+    const resolved = path.resolve(projectRoot, relativePath);
+    if (!resolved.startsWith(projectRoot + path.sep) && resolved !== projectRoot) {
+        throw new Error(`Path ${relativePath} resolves outside the project root.`);
+    }
+    return resolved;
+}
+export function createTools(projectRoot) {
+    const readFileTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "read_file",
+                description: "Read the contents of a file from the project root. Use a relative path.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Relative path to the file (e.g. src/index.ts)",
+                        },
+                        offset: {
+                            type: "number",
+                            description: "Line offset to start reading from (0-indexed). Default: 0",
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum number of lines to read. Default: 500",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const filePath = resolveProjectPath(args.path, projectRoot);
+            const offset = args.offset ?? 0;
+            const limit = args.limit ?? 500;
+            const content = await readFile(filePath, "utf8");
+            const lines = content.split("\n");
+            const end = Math.min(offset + limit, lines.length);
+            const result = lines.slice(offset, end).join("\n");
+            return truncateResult(result);
+        },
+    };
+    const writeFileTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "write_file",
+                description: "Write content to a file under .wiki/. Creates parent directories if needed. The path must be relative and start with .wiki/.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Relative path under .wiki/ (e.g. .wiki/quickstart.md)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The full content to write",
+                        },
+                    },
+                    required: ["path", "content"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const filePath = resolveWikiPath(args.path, projectRoot);
+            const content = args.content;
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, content, "utf8");
+            return `Wrote ${args.path}`;
+        },
+    };
+    const editFileTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "edit_file",
+                description: "Replace text in a file under .wiki/. Finds old_string and replaces with new_string.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Relative path under .wiki/ (e.g. .wiki/quickstart.md)",
+                        },
+                        old_string: {
+                            type: "string",
+                            description: "The text to find",
+                        },
+                        new_string: {
+                            type: "string",
+                            description: "The replacement text",
+                        },
+                    },
+                    required: ["path", "old_string", "new_string"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const filePath = resolveWikiPath(args.path, projectRoot);
+            const oldString = args.old_string;
+            const newString = args.new_string;
+            const content = await readFile(filePath, "utf8");
+            const newContent = content.replace(oldString, newString);
+            if (newContent === content) {
+                return `No match found for old_string in ${args.path}`;
+            }
+            await writeFile(filePath, newContent, "utf8");
+            return `Edited ${args.path}`;
+        },
+    };
+    const lsTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "ls",
+                description: "List the contents of a directory. Returns file and directory names.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Relative path to the directory (default: project root)",
+                        },
+                    },
+                    required: [],
+                },
+            },
+        },
+        handler: async (args) => {
+            const dirPath = resolveProjectPath(args.path ?? ".", projectRoot);
+            const entries = await readdir(dirPath, { withFileTypes: true });
+            const result = entries
+                .map((e) => `${e.isDirectory() ? e.name + "/" : e.name}`)
+                .sort()
+                .join("\n");
+            return truncateResult(result || "(empty directory)");
+        },
+    };
+    const grepTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "grep",
+                description: "Search for a text pattern in files. Uses the system grep. Searches from the project root.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        pattern: {
+                            type: "string",
+                            description: "The text pattern to search for",
+                        },
+                        path: {
+                            type: "string",
+                            description: "Relative path to search in (default: project root)",
+                        },
+                        glob: {
+                            type: "string",
+                            description: "Optional glob pattern to filter files (e.g. *.ts)",
+                        },
+                    },
+                    required: ["pattern"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const pattern = args.pattern;
+            const searchPath = resolveProjectPath(args.path ?? ".", projectRoot);
+            const globPattern = args.glob ?? "";
+            const cmd = [
+                "grep",
+                "-rn",
+                "--include=" + (globPattern || "*.ts *.tsx *.js *.jsx *.py *.go *.rs *.java *.rb *.php *.md *.yml *.yaml *.json *.toml *.sh"),
+                "--",
+                pattern.replace(/'/g, "'\\''"),
+                searchPath,
+            ].join(" ");
+            try {
+                const { stdout } = await execAsync(cmd, {
+                    maxBuffer: 1024 * 1024,
+                });
+                return truncateResult(stdout || "(no matches)");
+            }
+            catch {
+                return "(no matches)";
+            }
+        },
+    };
+    const globTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "glob",
+                description: "Find files matching a pattern. Uses the system find command.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        pattern: {
+                            type: "string",
+                            description: "Glob pattern (e.g. *.ts, **/*.tsx). * matches within a directory, ** matches recursively.",
+                        },
+                        path: {
+                            type: "string",
+                            description: "Relative path to search in (default: project root)",
+                        },
+                    },
+                    required: ["pattern"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const pattern = args.pattern;
+            const searchPath = resolveProjectPath(args.path ?? ".", projectRoot);
+            const findPattern = pattern
+                .replace(/\*\*/g, "")
+                .replace(/\*/g, "");
+            const cmd = [
+                "find",
+                searchPath,
+                "-name",
+                `'${findPattern}'`,
+                "-type",
+                "f",
+                "-not",
+                "-path",
+                "'*/node_modules/*'",
+                "-not",
+                "-path",
+                "'*/.git/*'",
+                "-not",
+                "-path",
+                "'*/dist/*'",
+            ].join(" ");
+            try {
+                const { stdout } = await execAsync(cmd, {
+                    maxBuffer: 1024 * 1024,
+                });
+                return truncateResult(stdout || "(no files found)");
+            }
+            catch {
+                return "(no files found)";
+            }
+        },
+    };
+    const gitTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "git",
+                description: "Run a read-only git subcommand in the project root. Use for git log, git diff, git show, git ls-files, git blame, etc. The agent has no general shell access — only git is exposed for repository history and inspection.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        args: {
+                            type: "string",
+                            description: "Git subcommand and arguments, without the leading 'git'. Example: 'log --oneline -30', 'diff --stat', 'ls-files', 'show HEAD:README.md'.",
+                        },
+                    },
+                    required: ["args"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const argString = args.args ?? "";
+            // Only read-only / inspection subcommands are permitted. The agent
+            // cannot mutate the repository state through this tool. Flags that
+            // would mutate state (e.g. -d, -D, --delete) are blocked by the
+            // metacharacter guard below for any subcommand that accepts them, but
+            // the list itself excludes mutating subcommands entirely.
+            const ALLOWED_GIT_SUBCOMMANDS = {
+                log: true, diff: true, show: true, "ls-files": true, blame: true,
+                status: true, remote: true, describe: true, "rev-parse": true,
+                shortlog: true, "name-rev": true, "ls-tree": true, "cat-file": true,
+                reflog: true,
+            };
+            const tokens = argString.trim().split(/\s+/);
+            const subcommand = tokens[0] ?? "";
+            if (!ALLOWED_GIT_SUBCOMMANDS[subcommand]) {
+                return `Error: git subcommand '${subcommand}' is not permitted. Only read-only inspection subcommands are allowed (log, diff, show, ls-files, blame, status, remote, describe, rev-parse, shortlog, name-rev, ls-tree, cat-file, reflog).`;
+            }
+            // Reject shell metacharacters that could chain commands or inject
+            // flags. Git flags begin with '-', which we permit, so the guard
+            // focuses on shell-control and redirection metacharacters.
+            if (/[;&|`$()<>]/.test(argString)) {
+                return "Error: shell metacharacters are not permitted in git arguments.";
+            }
+            try {
+                const { stdout, stderr } = await execAsync(`git ${argString}`, {
+                    cwd: projectRoot,
+                    maxBuffer: 1024 * 1024,
+                    timeout: 30_000,
+                });
+                const result = stdout + (stderr ? `\n${stderr}` : "");
+                return truncateResult(result || "(no output)");
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return truncateResult(`Error: ${message}`);
+            }
+        },
+    };
+    const astGrepTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "ast_grep",
+                description: "Search code by AST pattern using ast-grep. Matches code structure (not text), so metavariables and node shapes work. Requires an explicit language. Use for precise structural queries like finding all calls to a function, all exports, or a specific control-flow shape.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        pattern: {
+                            type: "string",
+                            description: "AST pattern to match. Use $NAME for a single node metavariable and $$$ARGS for zero-or-more. Example: 'console.log($$$)'",
+                        },
+                        lang: {
+                            type: "string",
+                            description: "Language of the pattern. Supported: bash, c, cpp, csharp, css, elixir, go, haskell, html, java, javascript, json, jsx, kotlin, lua, nix, php, python, ruby, rust, scala, solidity, swift, tsx, typescript, yaml.",
+                        },
+                        path: {
+                            type: "string",
+                            description: "Relative path to search in (default: project root)",
+                        },
+                        selector: {
+                            type: "string",
+                            description: "Optional AST kind to extract as the actual matcher (ast-grep --selector).",
+                        },
+                        strictness: {
+                            type: "string",
+                            description: "Optional pattern strictness: cst, smart, ast, relaxed, signature, template.",
+                        },
+                    },
+                    required: ["pattern", "lang"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const pattern = args.pattern;
+            const lang = args.lang;
+            const searchPath = resolveProjectPath(args.path ?? ".", projectRoot);
+            const cmd = [
+                "ast-grep",
+                "run",
+                "--json=compact",
+                "--lang",
+                `'${lang.replace(/'/g, "'\\''")}'`,
+                "--pattern",
+                `'${pattern.replace(/'/g, "'\\''")}'`,
+            ];
+            const selector = args.selector;
+            if (selector) {
+                cmd.push("--selector", `'${selector.replace(/'/g, "'\\''")}'`);
+            }
+            const strictness = args.strictness;
+            if (strictness) {
+                cmd.push("--strictness", `'${strictness.replace(/'/g, "'\\''")}'`);
+            }
+            cmd.push(`'${searchPath.replace(/'/g, "'\\''")}'`);
+            try {
+                const { stdout } = await execAsync(cmd.join(" "), {
+                    cwd: projectRoot,
+                    maxBuffer: 1024 * 1024,
+                    timeout: 30_000,
+                });
+                return truncateResult(stdout || "(no matches)");
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return truncateResult(`Error: ${message}`);
+            }
+        },
+    };
+    const astSearchTool = {
+        definition: {
+            type: "function",
+            function: {
+                name: "ast_search",
+                description: "Search code using an ast-grep YAML rule (inline). More powerful than ast_grep: supports relational/inside/has constraints and multiple rules separated by '---'. Use for complex structural queries that a single pattern cannot express.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        rule: {
+                            type: "string",
+                            description: "Inline ast-grep YAML rule(s). Must have id, language, and rule fields. Multiple rules separated by '---'.",
+                        },
+                        path: {
+                            type: "string",
+                            description: "Relative path to search in (default: project root)",
+                        },
+                    },
+                    required: ["rule"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const rule = args.rule;
+            const searchPath = resolveProjectPath(args.path ?? ".", projectRoot);
+            try {
+                const { stdout } = await execAsync(`ast-grep scan --json=compact --inline-rules '${rule.replace(/'/g, "'\\''")}' '${searchPath.replace(/'/g, "'\\''")}'`, {
+                    cwd: projectRoot,
+                    maxBuffer: 1024 * 1024,
+                    timeout: 30_000,
+                });
+                return truncateResult(stdout || "(no matches)");
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return truncateResult(`Error: ${message}`);
+            }
+        },
+    };
+    return [
+        readFileTool,
+        writeFileTool,
+        editFileTool,
+        lsTool,
+        grepTool,
+        globTool,
+        gitTool,
+        astGrepTool,
+        astSearchTool,
+    ];
+}
+/**
+ * Execute a tool by name with the given arguments.
+ */
+export async function executeTool(toolName, args, projectRoot) {
+    const tools = createTools(projectRoot);
+    const tool = tools.find((t) => t.definition.function.name === toolName);
+    if (!tool) {
+        return `Unknown tool: ${toolName}`;
+    }
+    try {
+        return await tool.handler(args, projectRoot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error: ${message}`;
+    }
+}
+export { MAX_READ_LENGTH, MAX_TOOL_RESULT_LENGTH };

package/dist/tui/App.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { type ResolvedConfig } from "../config.js";
+interface AppProps {
+    command: "init" | "update";
+    cwd: string;
+    config: ResolvedConfig;
+    verbose: boolean;
+}
+export declare function App({ command, cwd, config, verbose }: AppProps): React.ReactElement;
+export {};

package/dist/tui/App.js

@@ -0,0 +1,31 @@
+import React, { useState, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { CredentialsSetup } from "./CredentialsSetup.js";
+import { RunView } from "./RunView.js";
+export function App({ command, cwd, config, verbose }) {
+    const [needsSetup, setNeedsSetup] = useState(config.mode === "cloud" && !config.apiKey);
+    const [resolvedConfig, setResolvedConfig] = useState(config);
+    const { exit } = useApp();
+    useInput((input) => {
+        if (input === "q" || input === "\u0003") {
+            exit();
+        }
+    });
+    const handleConfigSaved = useCallback((newConfig) => {
+        setResolvedConfig(newConfig);
+        setNeedsSetup(false);
+    }, []);
+    if (needsSetup) {
+        return React.createElement(CredentialsSetup, {
+            cwd,
+            onConfigSaved: handleConfigSaved,
+        });
+    }
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 }, React.createElement(Text, null, React.createElement(Text, { bold: true }, "Wiki Agent v0.1.0"), " | ", React.createElement(Text, { color: "cyan" }, `Ollama (${resolvedConfig.mode})`), " | ", React.createElement(Text, { color: "gray" }, `model: ${resolvedConfig.model}`), " | ", React.createElement(Text, { color: "gray" }, cwd))), React.createElement(RunView, {
+        command,
+        cwd,
+        config: resolvedConfig,
+        verbose,
+        onExit: exit,
+    }));
+}

package/dist/tui/CredentialsSetup.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { type ResolvedConfig } from "../config.js";
+interface CredentialsSetupProps {
+    cwd: string;
+    onConfigSaved: (config: ResolvedConfig) => void;
+}
+export declare function CredentialsSetup({ onConfigSaved, }: CredentialsSetupProps): React.ReactElement;
+export {};

package/dist/tui/CredentialsSetup.js

@@ -0,0 +1,74 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { saveGlobalConfig } from "../config.js";
+export function CredentialsSetup({ onConfigSaved, }) {
+    const [step, setStep] = useState("mode-select");
+    const [mode, setMode] = useState("local");
+    const [apiKey, setApiKey] = useState("");
+    const [model, setModel] = useState("kimi-k2.7-code");
+    const [error, setError] = useState(null);
+    async function handleSave() {
+        setError(null);
+        setStep("saving");
+        try {
+            const globalConfig = {
+                mode,
+                defaultModel: model,
+                ...(mode === "cloud" ? { apiKey } : {}),
+            };
+            await saveGlobalConfig(globalConfig);
+            const resolved = {
+                mode,
+                ...(mode === "cloud" ? { apiKey } : {}),
+                baseUrl: mode === "cloud" ? "https://ollama.com" : "http://localhost:11434",
+                model,
+            };
+            onConfigSaved(resolved);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setStep("mode-select");
+        }
+    }
+    useInput((input) => {
+        if (step === "mode-select") {
+            if (input === "1") {
+                setMode("local");
+                setStep("model");
+            }
+            else if (input === "2") {
+                setMode("cloud");
+                setStep("api-key");
+            }
+        }
+    });
+    if (step === "saving") {
+        return React.createElement(Box, null, React.createElement(Text, { color: "cyan" }, "Saving configuration..."));
+    }
+    if (step === "mode-select") {
+        return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { bold: true }, "Select Ollama mode:"), React.createElement(Text, null, React.createElement(Text, { color: "green" }, "  1. "), "Ollama Local (no API key required)"), React.createElement(Text, null, React.createElement(Text, { color: "green" }, "  2. "), "Ollama Cloud (API key required)"), React.createElement(Text, { color: "gray" }, "\nPress 1 or 2 to select."), error ? React.createElement(Text, { color: "red" }, `Error: ${error}`) : null);
+    }
+    if (step === "api-key") {
+        return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { bold: true }, "Enter your Ollama Cloud API key:"), React.createElement(Text, { color: "gray" }, "Get your API key from https://ollama.com"), React.createElement(TextInput, {
+            value: apiKey,
+            onChange: setApiKey,
+            onSubmit: () => {
+                if (!apiKey.trim()) {
+                    setError("API key is required for cloud mode.");
+                    return;
+                }
+                setError(null);
+                setStep("model");
+            },
+        }), error ? React.createElement(Text, { color: "red" }, `Error: ${error}`) : null);
+    }
+    // model step
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { bold: true }, "Enter default model ID:"), React.createElement(Text, { color: "gray" }, "Press Enter to use the default (kimi-k2.7-code)"), React.createElement(TextInput, {
+        value: model,
+        onChange: setModel,
+        onSubmit: () => {
+            void handleSave();
+        },
+    }));
+}

package/dist/tui/RunView.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { type ResolvedConfig } from "../config.js";
+import type { WikiCommand } from "../prompt.js";
+interface RunViewProps {
+    command: WikiCommand;
+    cwd: string;
+    config: ResolvedConfig;
+    verbose: boolean;
+    onExit: () => void;
+}
+export declare function RunView({ command, cwd, config, verbose, onExit, }: RunViewProps): React.ReactElement;
+export {};