@neuralnomads/codenomad 0.1.0

package/dist/api-types.js

@@ -0,0 +1 @@
+export const WINDOWS_DRIVES_ROOT = "__drives__";

package/dist/bin.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const cliEntry = path.join(__dirname, "index.js");
+const loaderFileUrl = pathToFileURL(path.join(__dirname, "loader.js")).href;
+const registerScript = `import { register } from "node:module"; import { pathToFileURL } from "node:url"; register("${encodeURI(loaderFileUrl)}", pathToFileURL("./"));`;
+const loaderArg = `data:text/javascript,${registerScript}`;
+const child = spawn(process.execPath, ["--import", loaderArg, cliEntry, ...process.argv.slice(2)], {
+    stdio: "inherit",
+});
+child.on("exit", (code, signal) => {
+    if (signal) {
+        process.kill(process.pid, signal);
+        return;
+    }
+    process.exit(code ?? 0);
+});
+child.on("error", (error) => {
+    console.error("Failed to launch CLI runtime", error);
+    process.exit(1);
+});

package/dist/config/binaries.js

@@ -0,0 +1,118 @@
+export class BinaryRegistry {
+    constructor(configStore, eventBus, logger) {
+        this.configStore = configStore;
+        this.eventBus = eventBus;
+        this.logger = logger;
+    }
+    list() {
+        return this.mapRecords();
+    }
+    resolveDefault() {
+        const binaries = this.mapRecords();
+        if (binaries.length === 0) {
+            this.logger.warn("No configured binaries found, falling back to opencode");
+            return this.buildFallbackRecord("opencode");
+        }
+        return binaries.find((binary) => binary.isDefault) ?? binaries[0];
+    }
+    create(request) {
+        this.logger.debug({ path: request.path }, "Registering OpenCode binary");
+        const entry = {
+            path: request.path,
+            version: undefined,
+            lastUsed: Date.now(),
+            label: request.label,
+        };
+        const config = this.configStore.get();
+        const nextConfig = this.cloneConfig(config);
+        const deduped = nextConfig.opencodeBinaries.filter((binary) => binary.path !== request.path);
+        nextConfig.opencodeBinaries = [entry, ...deduped];
+        if (request.makeDefault) {
+            nextConfig.preferences.lastUsedBinary = request.path;
+        }
+        this.configStore.replace(nextConfig);
+        const record = this.getById(request.path);
+        this.emitChange();
+        return record;
+    }
+    update(id, updates) {
+        this.logger.debug({ id }, "Updating OpenCode binary");
+        const config = this.configStore.get();
+        const nextConfig = this.cloneConfig(config);
+        nextConfig.opencodeBinaries = nextConfig.opencodeBinaries.map((binary) => binary.path === id ? { ...binary, label: updates.label ?? binary.label } : binary);
+        if (updates.makeDefault) {
+            nextConfig.preferences.lastUsedBinary = id;
+        }
+        this.configStore.replace(nextConfig);
+        const record = this.getById(id);
+        this.emitChange();
+        return record;
+    }
+    remove(id) {
+        this.logger.debug({ id }, "Removing OpenCode binary");
+        const config = this.configStore.get();
+        const nextConfig = this.cloneConfig(config);
+        const remaining = nextConfig.opencodeBinaries.filter((binary) => binary.path !== id);
+        nextConfig.opencodeBinaries = remaining;
+        if (nextConfig.preferences.lastUsedBinary === id) {
+            nextConfig.preferences.lastUsedBinary = remaining[0]?.path;
+        }
+        this.configStore.replace(nextConfig);
+        this.emitChange();
+    }
+    validatePath(path) {
+        this.logger.debug({ path }, "Validating OpenCode binary path");
+        return this.validateRecord({
+            id: path,
+            path,
+            label: this.prettyLabel(path),
+            isDefault: false,
+        });
+    }
+    cloneConfig(config) {
+        return JSON.parse(JSON.stringify(config));
+    }
+    mapRecords() {
+        const config = this.configStore.get();
+        const configuredBinaries = config.opencodeBinaries.map((binary) => ({
+            id: binary.path,
+            path: binary.path,
+            label: binary.label ?? this.prettyLabel(binary.path),
+            version: binary.version,
+            isDefault: false,
+        }));
+        const defaultPath = config.preferences.lastUsedBinary ?? configuredBinaries[0]?.path ?? "opencode";
+        const annotated = configuredBinaries.map((binary) => ({
+            ...binary,
+            isDefault: binary.path === defaultPath,
+        }));
+        if (!annotated.some((binary) => binary.path === defaultPath)) {
+            annotated.unshift(this.buildFallbackRecord(defaultPath));
+        }
+        return annotated;
+    }
+    getById(id) {
+        return this.mapRecords().find((binary) => binary.id === id) ?? this.buildFallbackRecord(id);
+    }
+    emitChange() {
+        this.logger.debug("Emitting binaries changed event");
+        this.eventBus?.publish({ type: "config.binariesChanged", binaries: this.mapRecords() });
+    }
+    validateRecord(record) {
+        // TODO: call actual binary -v check.
+        return { valid: true, version: record.version };
+    }
+    buildFallbackRecord(path) {
+        return {
+            id: path,
+            path,
+            label: this.prettyLabel(path),
+            isDefault: true,
+        };
+    }
+    prettyLabel(path) {
+        const parts = path.split(/[\\/]/);
+        const last = parts[parts.length - 1] || path;
+        return last || path;
+    }
+}

package/dist/config/schema.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+const ModelPreferenceSchema = z.object({
+    providerId: z.string(),
+    modelId: z.string(),
+});
+const AgentModelSelectionSchema = z.record(z.string(), ModelPreferenceSchema);
+const AgentModelSelectionsSchema = z.record(z.string(), AgentModelSelectionSchema);
+const PreferencesSchema = z.object({
+    showThinkingBlocks: z.boolean().default(false),
+    lastUsedBinary: z.string().optional(),
+    environmentVariables: z.record(z.string()).default({}),
+    modelRecents: z.array(ModelPreferenceSchema).default([]),
+    diffViewMode: z.enum(["split", "unified"]).default("split"),
+    toolOutputExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    diagnosticsExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+});
+const RecentFolderSchema = z.object({
+    path: z.string(),
+    lastAccessed: z.number().nonnegative(),
+});
+const OpenCodeBinarySchema = z.object({
+    path: z.string(),
+    version: z.string().optional(),
+    lastUsed: z.number().nonnegative(),
+    label: z.string().optional(),
+});
+const ConfigFileSchema = z.object({
+    preferences: PreferencesSchema.default({}),
+    recentFolders: z.array(RecentFolderSchema).default([]),
+    opencodeBinaries: z.array(OpenCodeBinarySchema).default([]),
+    theme: z.enum(["light", "dark", "system"]).optional(),
+});
+const DEFAULT_CONFIG = ConfigFileSchema.parse({});
+export { ModelPreferenceSchema, AgentModelSelectionSchema, AgentModelSelectionsSchema, PreferencesSchema, RecentFolderSchema, OpenCodeBinarySchema, ConfigFileSchema, DEFAULT_CONFIG, };

package/dist/config/store.js

@@ -0,0 +1,68 @@
+import fs from "fs";
+import path from "path";
+import { ConfigFileSchema, DEFAULT_CONFIG } from "./schema";
+export class ConfigStore {
+    constructor(configPath, eventBus, logger) {
+        this.configPath = configPath;
+        this.eventBus = eventBus;
+        this.logger = logger;
+        this.cache = DEFAULT_CONFIG;
+        this.loaded = false;
+    }
+    load() {
+        if (this.loaded) {
+            return this.cache;
+        }
+        try {
+            const resolved = this.resolvePath(this.configPath);
+            if (fs.existsSync(resolved)) {
+                const content = fs.readFileSync(resolved, "utf-8");
+                const parsed = JSON.parse(content);
+                this.cache = ConfigFileSchema.parse(parsed);
+                this.logger.debug({ resolved }, "Loaded existing config file");
+            }
+            else {
+                this.cache = DEFAULT_CONFIG;
+                this.logger.debug({ resolved }, "No config file found, using defaults");
+            }
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to load config, using defaults");
+            this.cache = DEFAULT_CONFIG;
+        }
+        this.loaded = true;
+        return this.cache;
+    }
+    get() {
+        return this.load();
+    }
+    replace(config) {
+        const validated = ConfigFileSchema.parse(config);
+        this.commit(validated);
+    }
+    commit(next) {
+        this.cache = next;
+        this.loaded = true;
+        this.persist();
+        this.eventBus?.publish({ type: "config.appChanged", config: this.cache });
+        this.logger.info("Config updated");
+        this.logger.debug({ config: this.cache }, "Config payload");
+    }
+    persist() {
+        try {
+            const resolved = this.resolvePath(this.configPath);
+            fs.mkdirSync(path.dirname(resolved), { recursive: true });
+            fs.writeFileSync(resolved, JSON.stringify(this.cache, null, 2), "utf-8");
+            this.logger.debug({ resolved }, "Persisted config file");
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to persist config");
+        }
+    }
+    resolvePath(filePath) {
+        if (filePath.startsWith("~/")) {
+            return path.join(process.env.HOME ?? "", filePath.slice(2));
+        }
+        return path.resolve(filePath);
+    }
+}

package/dist/events/bus.js

@@ -0,0 +1,32 @@
+import { EventEmitter } from "events";
+export class EventBus extends EventEmitter {
+    constructor(logger) {
+        super();
+        this.logger = logger;
+    }
+    publish(event) {
+        this.logger?.debug({ event }, "Publishing workspace event");
+        return super.emit(event.type, event);
+    }
+    onEvent(listener) {
+        const handler = (event) => listener(event);
+        this.on("workspace.created", handler);
+        this.on("workspace.started", handler);
+        this.on("workspace.error", handler);
+        this.on("workspace.stopped", handler);
+        this.on("workspace.log", handler);
+        this.on("config.appChanged", handler);
+        this.on("config.binariesChanged", handler);
+        this.on("instance.dataChanged", handler);
+        return () => {
+            this.off("workspace.created", handler);
+            this.off("workspace.started", handler);
+            this.off("workspace.error", handler);
+            this.off("workspace.stopped", handler);
+            this.off("workspace.log", handler);
+            this.off("config.appChanged", handler);
+            this.off("config.binariesChanged", handler);
+            this.off("instance.dataChanged", handler);
+        };
+    }
+}

package/dist/filesystem/__tests__/search-cache.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { beforeEach, describe, it } from "node:test";
+import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates, WORKSPACE_CANDIDATE_CACHE_TTL_MS, } from "../search-cache";
+describe("workspace search cache", () => {
+    beforeEach(() => {
+        clearWorkspaceSearchCache();
+    });
+    it("expires cached candidates after the TTL", () => {
+        const workspacePath = "/tmp/workspace";
+        const startTime = 1000;
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
+        const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
+        assert.ok(beforeExpiry);
+        assert.equal(beforeExpiry.length, 1);
+        assert.equal(beforeExpiry[0].name, "file-a");
+        const afterExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS + 1);
+        assert.equal(afterExpiry, undefined);
+    });
+    it("replaces cached entries when manually refreshed", () => {
+        const workspacePath = "/tmp/workspace";
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
+        const initial = getWorkspaceCandidates(workspacePath);
+        assert.ok(initial);
+        assert.equal(initial[0].name, "file-a");
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
+        const refreshed = getWorkspaceCandidates(workspacePath);
+        assert.ok(refreshed);
+        assert.equal(refreshed[0].name, "file-b");
+    });
+});
+function createEntry(name) {
+    return {
+        name,
+        path: name,
+        absolutePath: `/tmp/${name}`,
+        type: "file",
+        size: 1,
+        modifiedAt: new Date().toISOString(),
+    };
+}

package/dist/filesystem/browser.js

@@ -0,0 +1,238 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { WINDOWS_DRIVES_ROOT, } from "../api-types";
+const WINDOWS_DRIVE_LETTERS = Array.from({ length: 26 }, (_, i) => String.fromCharCode(65 + i));
+export class FileSystemBrowser {
+    constructor(options) {
+        this.root = path.resolve(options.rootDir);
+        this.unrestricted = Boolean(options.unrestricted);
+        this.homeDir = os.homedir();
+        this.isWindows = process.platform === "win32";
+    }
+    list(relativePath = ".", options = {}) {
+        if (this.unrestricted) {
+            throw new Error("Relative listing is unavailable when running with unrestricted root");
+        }
+        const includeFiles = options.includeFiles ?? true;
+        const normalizedPath = this.normalizeRelativePath(relativePath);
+        const absolutePath = this.toRestrictedAbsolute(normalizedPath);
+        return this.readDirectoryEntries(absolutePath, {
+            includeFiles,
+            formatPath: (entryName) => this.buildRelativePath(normalizedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveRestrictedAbsoluteChild(normalizedPath, entryName),
+        });
+    }
+    browse(targetPath, options = {}) {
+        const includeFiles = options.includeFiles ?? true;
+        if (this.unrestricted) {
+            return this.listUnrestricted(targetPath, includeFiles);
+        }
+        return this.listRestrictedWithMetadata(targetPath, includeFiles);
+    }
+    readFile(relativePath) {
+        if (this.unrestricted) {
+            throw new Error("readFile is not available in unrestricted mode");
+        }
+        const resolved = this.toRestrictedAbsolute(relativePath);
+        return fs.readFileSync(resolved, "utf-8");
+    }
+    listRestrictedWithMetadata(relativePath, includeFiles) {
+        const normalizedPath = this.normalizeRelativePath(relativePath);
+        const absolutePath = this.toRestrictedAbsolute(normalizedPath);
+        const entries = this.readDirectoryEntries(absolutePath, {
+            includeFiles,
+            formatPath: (entryName) => this.buildRelativePath(normalizedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveRestrictedAbsoluteChild(normalizedPath, entryName),
+        });
+        const metadata = {
+            scope: "restricted",
+            currentPath: normalizedPath,
+            parentPath: normalizedPath === "." ? undefined : this.getRestrictedParent(normalizedPath),
+            rootPath: this.root,
+            homePath: this.homeDir,
+            displayPath: this.resolveRestrictedAbsolute(normalizedPath),
+            pathKind: "relative",
+        };
+        return { entries, metadata };
+    }
+    listUnrestricted(targetPath, includeFiles) {
+        const resolvedPath = this.resolveUnrestrictedPath(targetPath);
+        if (this.isWindows && resolvedPath === WINDOWS_DRIVES_ROOT) {
+            return this.listWindowsDrives();
+        }
+        const entries = this.readDirectoryEntries(resolvedPath, {
+            includeFiles,
+            formatPath: (entryName) => this.resolveAbsoluteChild(resolvedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveAbsoluteChild(resolvedPath, entryName),
+        });
+        const parentPath = this.getUnrestrictedParent(resolvedPath);
+        const metadata = {
+            scope: "unrestricted",
+            currentPath: resolvedPath,
+            parentPath,
+            rootPath: this.homeDir,
+            homePath: this.homeDir,
+            displayPath: resolvedPath,
+            pathKind: "absolute",
+        };
+        return { entries, metadata };
+    }
+    listWindowsDrives() {
+        if (!this.isWindows) {
+            throw new Error("Drive listing is only supported on Windows hosts");
+        }
+        const entries = [];
+        for (const letter of WINDOWS_DRIVE_LETTERS) {
+            const drivePath = `${letter}:\\`;
+            try {
+                if (fs.existsSync(drivePath)) {
+                    entries.push({
+                        name: `${letter}:`,
+                        path: drivePath,
+                        absolutePath: drivePath,
+                        type: "directory",
+                    });
+                }
+            }
+            catch {
+                // Ignore inaccessible drives
+            }
+        }
+        // Provide a generic UNC root entry so users can navigate to network shares manually.
+        entries.push({
+            name: "UNC Network",
+            path: "\\\\",
+            absolutePath: "\\\\",
+            type: "directory",
+        });
+        const metadata = {
+            scope: "unrestricted",
+            currentPath: WINDOWS_DRIVES_ROOT,
+            parentPath: undefined,
+            rootPath: this.homeDir,
+            homePath: this.homeDir,
+            displayPath: "Drives",
+            pathKind: "drives",
+        };
+        return { entries, metadata };
+    }
+    readDirectoryEntries(directory, options) {
+        const dirents = fs.readdirSync(directory, { withFileTypes: true });
+        const results = [];
+        for (const entry of dirents) {
+            if (!options.includeFiles && !entry.isDirectory()) {
+                continue;
+            }
+            const absoluteEntryPath = path.join(directory, entry.name);
+            let stats;
+            try {
+                stats = fs.statSync(absoluteEntryPath);
+            }
+            catch {
+                // Skip entries we cannot stat (insufficient permissions, etc.)
+                continue;
+            }
+            const isDirectory = entry.isDirectory();
+            if (!options.includeFiles && !isDirectory) {
+                continue;
+            }
+            results.push({
+                name: entry.name,
+                path: options.formatPath(entry.name),
+                absolutePath: options.formatAbsolutePath(entry.name),
+                type: isDirectory ? "directory" : "file",
+                size: isDirectory ? undefined : stats.size,
+                modifiedAt: stats.mtime.toISOString(),
+            });
+        }
+        return results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    normalizeRelativePath(input) {
+        if (!input || input === "." || input === "./" || input === "/") {
+            return ".";
+        }
+        let normalized = input.replace(/\\+/g, "/");
+        if (normalized.startsWith("./")) {
+            normalized = normalized.replace(/^\.\/+/, "");
+        }
+        if (normalized.startsWith("/")) {
+            normalized = normalized.replace(/^\/+/g, "");
+        }
+        return normalized === "" ? "." : normalized;
+    }
+    buildRelativePath(parent, child) {
+        if (!parent || parent === ".") {
+            return this.normalizeRelativePath(child);
+        }
+        return this.normalizeRelativePath(`${parent}/${child}`);
+    }
+    resolveRestrictedAbsolute(relativePath) {
+        return this.toRestrictedAbsolute(relativePath);
+    }
+    resolveRestrictedAbsoluteChild(parent, child) {
+        const normalized = this.buildRelativePath(parent, child);
+        return this.toRestrictedAbsolute(normalized);
+    }
+    toRestrictedAbsolute(relativePath) {
+        const normalized = this.normalizeRelativePath(relativePath);
+        const target = path.resolve(this.root, normalized);
+        const relativeToRoot = path.relative(this.root, target);
+        if (relativeToRoot.startsWith("..") || path.isAbsolute(relativeToRoot) && relativeToRoot !== "") {
+            throw new Error("Access outside of root is not allowed");
+        }
+        return target;
+    }
+    resolveUnrestrictedPath(input) {
+        if (!input || input === "." || input === "./") {
+            return this.homeDir;
+        }
+        if (this.isWindows) {
+            if (input === WINDOWS_DRIVES_ROOT) {
+                return WINDOWS_DRIVES_ROOT;
+            }
+            const normalized = path.win32.normalize(input);
+            if (/^[a-zA-Z]:/.test(normalized) || normalized.startsWith("\\\\")) {
+                return normalized;
+            }
+            return path.win32.resolve(this.homeDir, normalized);
+        }
+        if (input.startsWith("/")) {
+            return path.posix.normalize(input);
+        }
+        return path.posix.resolve(this.homeDir, input);
+    }
+    resolveAbsoluteChild(parent, child) {
+        if (this.isWindows) {
+            return path.win32.normalize(path.win32.join(parent, child));
+        }
+        return path.posix.normalize(path.posix.join(parent, child));
+    }
+    getRestrictedParent(relativePath) {
+        const normalized = this.normalizeRelativePath(relativePath);
+        if (normalized === ".") {
+            return undefined;
+        }
+        const segments = normalized.split("/");
+        segments.pop();
+        return segments.length === 0 ? "." : segments.join("/");
+    }
+    getUnrestrictedParent(currentPath) {
+        if (this.isWindows) {
+            const normalized = path.win32.normalize(currentPath);
+            const parsed = path.win32.parse(normalized);
+            if (normalized === WINDOWS_DRIVES_ROOT) {
+                return undefined;
+            }
+            if (normalized === parsed.root) {
+                return WINDOWS_DRIVES_ROOT;
+            }
+            return path.win32.dirname(normalized);
+        }
+        const normalized = path.posix.normalize(currentPath);
+        if (normalized === "/") {
+            return undefined;
+        }
+        return path.posix.dirname(normalized);
+    }
+}

package/dist/filesystem/search-cache.js

@@ -0,0 +1,43 @@
+import path from "path";
+export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30000;
+const workspaceCandidateCache = new Map();
+export function getWorkspaceCandidates(rootDir, now = Date.now()) {
+    const key = normalizeKey(rootDir);
+    const cached = workspaceCandidateCache.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    if (cached.expiresAt <= now) {
+        workspaceCandidateCache.delete(key);
+        return undefined;
+    }
+    return cloneEntries(cached.candidates);
+}
+export function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
+    const key = normalizeKey(rootDir);
+    const freshCandidates = builder();
+    if (!freshCandidates || freshCandidates.length === 0) {
+        workspaceCandidateCache.delete(key);
+        return [];
+    }
+    const storedCandidates = cloneEntries(freshCandidates);
+    workspaceCandidateCache.set(key, {
+        expiresAt: now + WORKSPACE_CANDIDATE_CACHE_TTL_MS,
+        candidates: storedCandidates,
+    });
+    return cloneEntries(storedCandidates);
+}
+export function clearWorkspaceSearchCache(rootDir) {
+    if (typeof rootDir === "undefined") {
+        workspaceCandidateCache.clear();
+        return;
+    }
+    const key = normalizeKey(rootDir);
+    workspaceCandidateCache.delete(key);
+}
+function cloneEntries(entries) {
+    return entries.map((entry) => ({ ...entry }));
+}
+function normalizeKey(rootDir) {
+    return path.resolve(rootDir);
+}