@cryptiklemur/lattice 4.0.2 → 5.0.0

package/dist/server/project/project-files.js

@@ -0,0 +1,274 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+export function readProjectClaudeMd(projectPath) {
+    var filePath = join(projectPath, "CLAUDE.md");
+    if (!existsSync(filePath))
+        return "";
+    try {
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+export function writeProjectClaudeMd(projectPath, content) {
+    writeFileSync(join(projectPath, "CLAUDE.md"), content, "utf-8");
+}
+export function readProjectClaudeSettings(projectPath) {
+    var filePath = join(projectPath, ".claude", "settings.json");
+    if (!existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function mergeProjectClaudeSettings(projectPath, updates) {
+    var existing = readProjectClaudeSettings(projectPath);
+    Object.assign(existing, updates);
+    var dir = join(projectPath, ".claude");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "settings.json"), JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+export function readProjectRules(projectPath) {
+    var dir = join(projectPath, ".claude", "rules");
+    if (!existsSync(dir))
+        return [];
+    var results = [];
+    try {
+        var files = readdirSync(dir);
+        for (var file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            try {
+                var content = readFileSync(join(dir, file), "utf-8");
+                results.push({ filename: file, content });
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return results;
+}
+export function writeProjectRules(projectPath, rules) {
+    var dir = join(projectPath, ".claude", "rules");
+    mkdirSync(dir, { recursive: true });
+    var incoming = new Set();
+    for (var rule of rules) {
+        incoming.add(rule.filename);
+    }
+    try {
+        var existing = readdirSync(dir);
+        for (var file of existing) {
+            if (file.endsWith(".md") && !incoming.has(file)) {
+                unlinkSync(join(dir, file));
+            }
+        }
+    }
+    catch {
+        // dir just created, nothing to delete
+    }
+    for (var rule of rules) {
+        writeFileSync(join(dir, rule.filename), rule.content, "utf-8");
+    }
+}
+export function readProjectMcpServers(projectPath) {
+    var filePath = join(projectPath, ".mcp.json");
+    if (!existsSync(filePath))
+        return {};
+    try {
+        var parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+        return parsed?.mcpServers ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+export function writeProjectMcpServers(projectPath, servers) {
+    var filePath = join(projectPath, ".mcp.json");
+    writeFileSync(filePath, JSON.stringify({ mcpServers: servers }, null, 2) + "\n", "utf-8");
+}
+export function readProjectSkills(projectPath) {
+    return scanSkillsDir(join(projectPath, ".claude", "skills"));
+}
+export function readGlobalRules() {
+    var dir = join(homedir(), ".claude", "rules");
+    if (!existsSync(dir))
+        return [];
+    var results = [];
+    try {
+        var files = readdirSync(dir);
+        for (var file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            try {
+                var content = readFileSync(join(dir, file), "utf-8");
+                results.push({ filename: file, content });
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return results;
+}
+export function readGlobalPermissions() {
+    var settings = readJsonFile(join(homedir(), ".claude", "settings.json"));
+    var local = readJsonFile(join(homedir(), ".claude", "settings.local.json"));
+    var allow = new Set();
+    var deny = new Set();
+    collectPermissions(settings, allow, deny);
+    collectPermissions(local, allow, deny);
+    return { allow: Array.from(allow), deny: Array.from(deny) };
+}
+export function readGlobalMcpServers() {
+    var filePath = join(homedir(), ".claude.json");
+    if (!existsSync(filePath))
+        return {};
+    try {
+        var parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+        return parsed?.mcpServers ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+export function writeGlobalMcpServers(servers) {
+    var filePath = join(homedir(), ".claude.json");
+    var existing = {};
+    if (existsSync(filePath)) {
+        try {
+            existing = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch { }
+    }
+    existing.mcpServers = servers;
+    writeFileSync(filePath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+export function readGlobalSkills() {
+    var results = [];
+    var dirs = [
+        join(homedir(), ".claude", "skills"),
+        join(homedir(), ".agents", "skills"),
+    ];
+    for (var dir of dirs) {
+        var skills = scanSkillsDir(dir);
+        for (var skill of skills) {
+            results.push(skill);
+        }
+    }
+    return results;
+}
+function readJsonFile(filePath) {
+    if (!existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function collectPermissions(obj, allow, deny) {
+    var perms = obj.permissions;
+    if (!perms)
+        return;
+    var allowArr = perms.allow;
+    var denyArr = perms.deny;
+    if (Array.isArray(allowArr)) {
+        for (var item of allowArr) {
+            if (typeof item === "string")
+                allow.add(item);
+        }
+    }
+    if (Array.isArray(denyArr)) {
+        for (var item of denyArr) {
+            if (typeof item === "string")
+                deny.add(item);
+        }
+    }
+}
+function parseFrontmatter(content) {
+    var match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return { name: "", description: "" };
+    var yaml = match[1];
+    var name = "";
+    var desc = "";
+    var lines = yaml.split(/\r?\n/);
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        var nameMatch = line.match(/^name:\s*(.+)/);
+        if (nameMatch)
+            name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+        var descMatch = line.match(/^description:\s*(.+)/);
+        if (descMatch)
+            desc = descMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    return { name, description: desc };
+}
+function scanSkillsDir(dir) {
+    if (!existsSync(dir))
+        return [];
+    var results = [];
+    try {
+        var entries = readdirSync(dir, { withFileTypes: true });
+        for (var entry of entries) {
+            var entryPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                try {
+                    var subFiles = readdirSync(entryPath);
+                    for (var subFile of subFiles) {
+                        if (subFile.toUpperCase().startsWith("SKILL")) {
+                            var skillPath = join(entryPath, subFile);
+                            var content = readFileSync(skillPath, "utf-8");
+                            var meta = parseFrontmatter(content);
+                            var skillName = meta.name || entry.name;
+                            var description = meta.description || firstNonEmptyLine(content.replace(/^---[\s\S]*?---\s*/, ""));
+                            results.push({ name: skillName, description, path: skillPath });
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // skip unreadable subdirectories
+                }
+            }
+            else if (entry.name.toUpperCase().startsWith("SKILL")) {
+                try {
+                    var content = readFileSync(entryPath, "utf-8");
+                    var meta = parseFrontmatter(content);
+                    var name = meta.name || entry.name.replace(/\.[^.]+$/, "");
+                    var description = meta.description || firstNonEmptyLine(content.replace(/^---[\s\S]*?---\s*/, ""));
+                    results.push({ name, description, path: entryPath });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return results;
+}
+function firstNonEmptyLine(text) {
+    var lines = text.split("\n");
+    for (var line of lines) {
+        var trimmed = line.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return "";
+}

package/dist/server/project/registry.js

@@ -0,0 +1,51 @@
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { loadConfig, saveConfig } from "../config.js";
+export function listProjects(nodeId) {
+    var config = loadConfig();
+    return config.projects.map(function (p) {
+        return {
+            slug: p.slug,
+            path: p.path,
+            title: p.title,
+            nodeId: nodeId,
+        };
+    });
+}
+export function addProject(path, title) {
+    if (!existsSync(path))
+        return null;
+    var config = loadConfig();
+    if (config.projects.some(function (p) { return p.path === path; }))
+        return null;
+    var slug = generateSlug(basename(path), config.projects.map(function (p) { return p.slug; }));
+    var project = { path: path, slug: slug, title: title || basename(path), env: {} };
+    config.projects.push(project);
+    saveConfig(config);
+    return { slug: project.slug, path: project.path, title: project.title, nodeId: "" };
+}
+export function removeProject(slug) {
+    var config = loadConfig();
+    var idx = config.projects.findIndex(function (p) { return p.slug === slug; });
+    if (idx === -1)
+        return false;
+    config.projects.splice(idx, 1);
+    saveConfig(config);
+    return true;
+}
+export function getProjectBySlug(slug) {
+    var config = loadConfig();
+    return config.projects.find(function (p) { return p.slug === slug; });
+}
+export function generateSlug(name, existing) {
+    var slug = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (!slug)
+        slug = "project";
+    var candidate = slug;
+    var counter = 1;
+    while (existing.includes(candidate)) {
+        candidate = slug + "-" + counter;
+        counter++;
+    }
+    return candidate;
+}