summer-engine 2.2.0 → 2.5.0

package/dist/commands/setup.js

@@ -11,6 +11,12 @@ const AGENT_LABEL = {
     codex: "Codex",
     cursor: "Cursor",
     windsurf: "Windsurf",
+    cline: "Cline",
+    "roo-code": "Roo Code",
+    gemini: "Gemini CLI",
+    "github-copilot": "GitHub Copilot CLI",
+    "vscode-copilot": "GitHub Copilot in VS Code",
+    opencode: "OpenCode",
 };
 export const setupCommand = new Command("setup")
     .description("Configure Summer Engine for an AI agent and run diagnostics")
@@ -21,6 +27,7 @@ export const setupCommand = new Command("setup")
     .option("--print", "Print the MCP config snippet instead of writing files")
     .option("--yes", "Apply practical setup steps without prompting")
     .option("--json", "Print setup result as JSON")
+    .option("--force", "Overwrite existing skill content (passes --force through to skills install)")
     .action(async (agentArg, opts) => {
     const agent = resolveAgent(agentArg, opts.agent);
     const scope = resolveScope(opts.scope);
@@ -33,6 +40,7 @@ export const setupCommand = new Command("setup")
     const skills = setupRecommendedSkills(agent, {
         dryRun: Boolean(opts.dryRun || opts.print),
         yes: Boolean(opts.yes),
+        force: Boolean(opts.force),
     });
     const doctor = await runDoctor({ quiet: true });
     if (opts.json) {
@@ -68,7 +76,7 @@ function resolveScope(scopeOpt) {
     return parsed;
 }
 function setupRecommendedSkills(agent, options) {
-    const invocation = skillInstallInvocation(agent);
+    const invocation = skillInstallInvocation(agent, { force: options.force });
     if (!invocation) {
         return {
             status: "skipped",
@@ -103,13 +111,15 @@ function setupRecommendedSkills(agent, options) {
         stderr: result.stderr.trim(),
     };
 }
-function skillInstallInvocation(agent) {
+function skillInstallInvocation(agent, opts = { force: false }) {
     const cliPath = process.argv[1];
     if (!cliPath)
         return null;
     const command = cliPath.endsWith(".js") ? process.execPath : cliPath;
     const prefix = cliPath.endsWith(".js") ? [cliPath] : [];
     const baseArgs = ["skills", "install", "--recommended", "--agent", agent];
+    if (opts.force)
+        baseArgs.push("--force");
     return {
         command,
         args: [...prefix, ...baseArgs],

package/dist/commands/skills.js

@@ -1,13 +1,21 @@
 import { Command } from "commander";
-import { existsSync, mkdirSync, readFileSync, cpSync, writeFileSync, } from "fs";
+import { existsSync, mkdirSync, readFileSync, cpSync, rmSync, writeFileSync, readdirSync, copyFileSync, } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
+import { homedir, platform } from "os";
+import { createRequire } from "node:module";
 import { AGENT_CLIENTS, SKILL_REGISTRY, } from "../lib/skills-registry.js";
 import { tildeify } from "../lib/format.js";
+import { writeSkillMarker } from "../lib/version-check.js";
+const requireFromHere = createRequire(import.meta.url);
+const { version: cliVersion } = requireFromHere("../../package.json");
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Resolve skills dir: from dist/commands/skills.js -> ../../skills
 const skillsDir = join(__dirname, "..", "..", "skills");
+// Resolve commands dir: same parent. Used by Claude Code installs to also copy
+// slash commands (e.g. /gameskill) to ~/.claude/commands/. Other agents don't
+// have an equivalent today, so the copy is gated to claude-code.
+const commandsDir = join(__dirname, "..", "..", "commands");
 const SKILL_SCOPES = ["user", "project"];
 function getBuiltinSkills() {
     const skills = [];
@@ -102,8 +110,12 @@ function resolveAgent(opts) {
 function resolveScope(agent, opts) {
     if (opts.scope)
         return parseScope(opts.scope);
-    if (agent === "cursor" || agent === "windsurf")
+    if (agent === "cursor" ||
+        agent === "windsurf" ||
+        agent === "cline" ||
+        agent === "roo-code") {
         return "project";
+    }
     return "user";
 }
 function agentLabel(agent) {
@@ -116,6 +128,18 @@ function agentLabel(agent) {
             return "Cursor";
         case "windsurf":
             return "Windsurf";
+        case "cline":
+            return "Cline";
+        case "roo-code":
+            return "Roo Code";
+        case "gemini":
+            return "Gemini CLI";
+        case "github-copilot":
+            return "GitHub Copilot CLI";
+        case "vscode-copilot":
+            return "GitHub Copilot in VS Code";
+        case "opencode":
+            return "OpenCode";
         case "summer":
             return "Summer";
     }
@@ -128,6 +152,15 @@ function resolveInstallLocation(agent, scope) {
         if (agent === "windsurf") {
             return { kind: "windsurf-rule-file", path: join(overrideDir, ".windsurfrules") };
         }
+        if (agent === "cline" || agent === "roo-code") {
+            return { kind: "cline-rule-dir", path: overrideDir };
+        }
+        if (agent === "gemini") {
+            return { kind: "gemini-skill-dir", path: overrideDir };
+        }
+        if (agent === "opencode") {
+            return { kind: "opencode-skill-dir", path: overrideDir };
+        }
         return { kind: "skill-dir", path: overrideDir };
     }
     const root = scope === "user" ? homedir() : process.cwd();
@@ -140,10 +173,63 @@ function resolveInstallLocation(agent, scope) {
             return { kind: "cursor-rule-dir", path: join(root, ".cursor", "rules") };
         case "windsurf":
             return { kind: "windsurf-rule-file", path: join(root, ".windsurfrules") };
+        case "cline":
+            return {
+                kind: "cline-rule-dir",
+                path: scope === "user"
+                    ? clineUserRulesDir()
+                    : join(process.cwd(), ".clinerules"),
+            };
+        case "roo-code":
+            return {
+                kind: "cline-rule-dir",
+                path: scope === "user"
+                    ? rooCodeUserRulesDir()
+                    : join(process.cwd(), ".clinerules"),
+            };
+        case "gemini":
+            return {
+                kind: "gemini-skill-dir",
+                path: join(homedir(), ".gemini", "extensions", "summer-engine", "skills"),
+            };
+        case "github-copilot":
+        case "vscode-copilot":
+            return {
+                kind: "skill-dir",
+                path: scope === "user"
+                    ? join(homedir(), ".copilot", "skills")
+                    : join(process.cwd(), ".github", "skills"),
+            };
+        case "opencode":
+            return {
+                kind: "opencode-skill-dir",
+                path: scope === "user"
+                    ? opencodeUserAgentsDir()
+                    : join(process.cwd(), ".opencode", "agents", "summer"),
+            };
         case "summer":
             return { kind: "skill-dir", path: join(root, ".summer", "skills") };
     }
 }
+function clineUserRulesDir() {
+    // Cline reads global rules from the user's Documents/Cline/Rules folder.
+    return join(homedir(), "Documents", "Cline", "Rules");
+}
+function rooCodeUserRulesDir() {
+    // Roo Code reads global rules from the user's Documents/Roo/Rules folder.
+    return join(homedir(), "Documents", "Roo", "Rules");
+}
+function opencodeUserAgentsDir() {
+    // OpenCode's user-scope agent definition directory varies by OS.
+    // On Windows, OpenCode reads from %APPDATA%/opencode/agents/summer.
+    // On Linux/macOS, it reads from $XDG_CONFIG_HOME or ~/.config/opencode/agents/summer.
+    if (platform() === "win32") {
+        const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+        return join(appData, "opencode", "agents", "summer");
+    }
+    const xdg = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+    return join(xdg, "opencode", "agents", "summer");
+}
 function selectSkills(name, opts) {
     if (opts.all && opts.recommended) {
         die("Use only one bulk option: --all or --recommended.");
@@ -178,26 +264,37 @@ function printAvailableSkillNames() {
         console.log(`  ${skill.name}`);
     }
 }
-function installSkill(skill, agent, location) {
+function installSkill(skill, agent, location, options) {
     if (!skill.clients.includes(agent)) {
         die(`${skill.name} does not support ${agentLabel(agent)}.`);
     }
     switch (location.kind) {
         case "skill-dir":
-            return copySkillDirectory(skill, location.path);
+            return copySkillDirectory(skill, location.path, options);
         case "cursor-rule-dir":
             return writeCursorRule(skill, location.path);
         case "windsurf-rule-file":
             return upsertWindsurfRule(skill, location.path);
+        case "cline-rule-dir":
+            return writeClineRule(skill, location.path);
+        case "gemini-skill-dir":
+            return writeGeminiSkill(skill, location.path);
+        case "opencode-skill-dir":
+            return writeOpencodeSkill(skill, location.path);
     }
 }
-function copySkillDirectory(skill, targetDir) {
+function copySkillDirectory(skill, targetDir, options) {
     const src = getSkillPath(skill.name);
     if (!src)
         die(`Skill files missing: ${skill.name}`);
     mkdirSync(targetDir, { recursive: true });
     const dest = join(targetDir, skill.name);
-    cpSync(src, dest, { recursive: true });
+    if (options.force && existsSync(dest)) {
+        // Wipe stale skill content so re-installs overwrite cleanly even if files
+        // were renamed or removed upstream.
+        rmSync(dest, { recursive: true, force: true });
+    }
+    cpSync(src, dest, { recursive: true, force: true });
     return { action: "Installed", path: dest };
 }
 function writeCursorRule(skill, rulesDir) {
@@ -219,6 +316,35 @@ function upsertWindsurfRule(skill, rulePath) {
     writeFileSync(rulePath, next, "utf-8");
     return { action: "Generated", path: rulePath };
 }
+function writeClineRule(skill, rulesDir) {
+    // Cline + Roo Code read project rules from .clinerules/ and global rules
+    // from Documents/Cline (or Roo)/Rules. Both expect plain markdown files.
+    // SKILL.md isn't recognized as a special filename, so we name files <skill>.md.
+    mkdirSync(rulesDir, { recursive: true });
+    const rulePath = join(rulesDir, `summer-${skill.name}.md`);
+    writeFileSync(rulePath, renderRuleBody(skill) + "\n", "utf-8");
+    return { action: "Generated", path: rulePath };
+}
+function writeGeminiSkill(skill, skillsDir) {
+    // Gemini extensions support a contextFileName, but skill discovery for
+    // arbitrary markdown is not standardized. We drop each SKILL.md alongside
+    // the extension so the agent can reference them by path; the install
+    // summary surfaces this so the user knows where to point Gemini.
+    mkdirSync(skillsDir, { recursive: true });
+    const rulePath = join(skillsDir, `${skill.name}.md`);
+    writeFileSync(rulePath, renderRuleBody(skill) + "\n", "utf-8");
+    return { action: "Generated", path: rulePath };
+}
+function writeOpencodeSkill(skill, skillsDir) {
+    // OpenCode supports agent markdown definitions; the exact discovery
+    // convention for ad-hoc skills isn't fully documented. We write each skill
+    // as a markdown file under agents/summer/ so OpenCode can reference them
+    // directly. The install summary shows the path.
+    mkdirSync(skillsDir, { recursive: true });
+    const rulePath = join(skillsDir, `${skill.name}.md`);
+    writeFileSync(rulePath, renderRuleBody(skill) + "\n", "utf-8");
+    return { action: "Generated", path: rulePath };
+}
 function renderCursorRule(skill) {
     const description = `Summer skill ${skill.name}: ${skill.description}`;
     return `---\ndescription: ${JSON.stringify(description)}\nglobs: []\nalwaysApply: false\n---\n\n${renderRuleBody(skill)}\n`;
@@ -251,6 +377,18 @@ function printInstallSummary(count, agent, scope, location) {
     else if (location.kind === "cursor-rule-dir") {
         console.log(`Cursor rules are in ${tildeified}/summer-<skill>.mdc`);
     }
+    else if (location.kind === "cline-rule-dir") {
+        console.log(`${label} rules are in ${tildeified}/summer-<skill>.md`);
+        console.log("Restart VS Code to pick up new rules.");
+    }
+    else if (location.kind === "gemini-skill-dir") {
+        console.log(`Skill files are in ${tildeified}/<skill>.md`);
+        console.log("Reference them from Gemini by path, or run `gemini extensions enable summer-engine` to load the bundled context.");
+    }
+    else if (location.kind === "opencode-skill-dir") {
+        console.log(`Skill files are in ${tildeified}/<skill>.md`);
+        console.log("Restart OpenCode so it picks up the new agent definitions.");
+    }
     else {
         console.log(`Windsurf rules are in ${tildeified}`);
     }
@@ -287,6 +425,7 @@ skillsCommand
     .option("--scope <scope>", "Install scope: user or project")
     .option("--as-claude-skill", "Legacy alias for --agent claude-code")
     .option("--as-cursor-skill", "Legacy alias for --agent cursor")
+    .option("--force", "Overwrite existing skill files (wipe stale skill dirs before copying)")
     .action((name, opts) => {
     const agent = resolveAgent(opts);
     const scope = resolveScope(agent, opts);
@@ -297,11 +436,69 @@ skillsCommand
         return;
     }
     for (const skill of skills) {
-        const result = installSkill(skill, agent, location);
+        const result = installSkill(skill, agent, location, {
+            force: Boolean(opts.force),
+        });
         console.log(`  ${result.action} ${skill.name} -> ${result.path}`);
     }
+    // Claude Code: also install slash commands (`tools/summer-cli/commands/*.md`)
+    // into `~/.claude/commands/`. Other agents don't have an equivalent today.
+    if (agent === "claude-code") {
+        const commandResults = installClaudeCommands(scope, Boolean(opts.force));
+        for (const r of commandResults) {
+            console.log(`  ${r.action} command ${r.name} -> ${r.path}`);
+        }
+    }
+    writeMarkerForLocation(location);
     printInstallSummary(skills.length, agent, scope, location);
 });
+/**
+ * Copy every `.md` file in `tools/summer-cli/commands/` to the user's
+ * `~/.claude/commands/` directory so the slash commands (e.g. `/gameskill`)
+ * are available on every machine that runs `summer skills install`.
+ *
+ * Project-scope installs go to `<cwd>/.claude/commands/`. Returns one result
+ * per command file copied. Silent no-op if no commands directory exists in
+ * the package (older summer-cli releases didn't ship one).
+ */
+function installClaudeCommands(scope, force) {
+    if (!existsSync(commandsDir))
+        return [];
+    const root = scope === "user" ? homedir() : process.cwd();
+    const targetDir = join(root, ".claude", "commands");
+    mkdirSync(targetDir, { recursive: true });
+    const results = [];
+    for (const entry of readdirSync(commandsDir)) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const src = join(commandsDir, entry);
+        const dest = join(targetDir, entry);
+        if (existsSync(dest) && !force) {
+            results.push({ action: "Kept", name: entry, path: dest });
+            continue;
+        }
+        copyFileSync(src, dest);
+        results.push({ action: "Installed", name: entry, path: dest });
+    }
+    return results;
+}
+/**
+ * Drop a `.summer-version` marker into the install dir so doctor's
+ * `skills-version-stale` check can detect drift later. Windsurf writes a
+ * single rules file with no surrounding dir, so we skip it there.
+ */
+function writeMarkerForLocation(location) {
+    if (location.kind === "windsurf-rule-file")
+        return;
+    try {
+        mkdirSync(location.path, { recursive: true });
+        writeSkillMarker(location.path, cliVersion);
+    }
+    catch {
+        // Marker is purely informational. If the FS rejects it (e.g. permission
+        // surprises on locked-down corp machines) we don't want to fail the install.
+    }
+}
 skillsCommand
     .command("info <name>")
     .description("Show skill description and preview")

package/dist/commands/status.js

@@ -1,6 +1,8 @@
 import { Command } from "commander";
 import { getAuthToken, getUserInfo } from "../lib/auth.js";
 import { getApiToken, getApiPort, checkEngineHealth } from "../lib/engine.js";
+import { getProjectMemorySummary } from "../lib/project-memory.js";
+import { formatStatusMemoryLine } from "./memory.js";
 export const statusCommand = new Command("status")
     .description("Check Summer Engine status, connection, and auth state")
     .action(async () => {
@@ -36,6 +38,7 @@ export const statusCommand = new Command("status")
     }
     if (health.project_path) {
         console.log(`  Path: ${health.project_path}`);
+        console.log(`  ${formatStatusMemoryLine(getProjectMemorySummary(health.project_path))}`);
     }
     if (health.scene) {
         console.log(`  Scene: ${health.scene}`);

package/dist/lib/agent-config.d.ts

@@ -1,5 +1,5 @@
 export declare const SUMMER_MCP_SERVER_NAME = "summer-engine";
-export declare const supportedAgents: readonly ["codex", "claude-code", "cursor", "windsurf"];
+export declare const supportedAgents: readonly ["codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "gemini", "github-copilot", "vscode-copilot", "opencode"];
 export type SupportedAgent = (typeof supportedAgents)[number];
 export type ConfigScope = "user" | "project";
 export interface StdioMcpServerConfig {
@@ -22,7 +22,7 @@ export interface AgentConfigResult {
     path: string;
     serverName: string;
     server: StdioMcpServerConfig;
-    format: "json" | "toml";
+    format: "json" | "toml" | "json-opencode" | "json-copilot" | "json-vscode";
     snippet: string;
     changed: boolean;
     wrote: boolean;