supipowers 0.1.0 → 0.1.3

package/bin/install.mjs

@@ -12,8 +12,8 @@ import {
   note,
 } from "@clack/prompts";
 import { spawnSync } from "node:child_process";
-import { readdirSync, readFileSync, existsSync } from "node:fs";
-import { resolve, extname, dirname, join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 
@@ -59,53 +59,29 @@ function findOmpBinary() {
 const LSP_SERVERS = [
   {
     language: "TypeScript / JavaScript",
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
     server: "typescript-language-server",
     installCmd: "bun add -g typescript-language-server typescript",
   },
   {
     language: "Python",
-    extensions: [".py"],
     server: "pyright",
     installCmd: "pip install pyright",
   },
   {
     language: "Rust",
-    extensions: [".rs"],
     server: "rust-analyzer",
     installCmd: "rustup component add rust-analyzer",
   },
   {
     language: "Go",
-    extensions: [".go"],
     server: "gopls",
     installCmd: "go install golang.org/x/tools/gopls@latest",
   },
 ];
 
-function detectLanguages(dir) {
-  const detected = new Set();
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        detected.add(extname(entry.name));
-      } else if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        // One level deep
-        try {
-          const subEntries = readdirSync(join(dir, entry.name), { withFileTypes: true });
-          for (const sub of subEntries) {
-            if (sub.isFile()) detected.add(extname(sub.name));
-          }
-        } catch {
-          // skip unreadable dirs
-        }
-      }
-    }
-  } catch {
-    // skip
-  }
-  return detected;
+function isInstalled(binary) {
+  const result = run("which", [binary]);
+  return result.status === 0;
 }
 
 // ── Main ─────────────────────────────────────────────────────
@@ -178,33 +154,33 @@ async function main() {
 
   // ── Step 3: LSP setup (optional) ──────────────────────────
 
-  const detectedExts = detectLanguages(process.cwd());
-  const matchingServers = LSP_SERVERS.filter((srv) =>
-    srv.extensions.some((ext) => detectedExts.has(ext))
-  );
-
-  if (matchingServers.length > 0) {
-    const selected = await multiselect({
-      message: "Detected project languages. Install LSP servers for better code intelligence?",
-      options: matchingServers.map((srv) => ({
+  const selected = await multiselect({
+    message: "Install LSP servers for better code intelligence?",
+    options: LSP_SERVERS.map((srv) => {
+      const installed = isInstalled(srv.server);
+      return {
         value: srv,
         label: srv.language,
-        hint: srv.server,
-      })),
-      required: false,
-    });
+        hint: installed ? `${srv.server} (installed)` : srv.server,
+      };
+    }),
+    required: false,
+  });
 
-    if (!isCancel(selected) && selected.length > 0) {
-      for (const srv of selected) {
-        const ls = spinner();
-        ls.start(`Installing ${srv.server}...`);
-        const [cmd, ...args] = srv.installCmd.split(" ");
-        const r = run(cmd, args);
-        if (r.status !== 0) {
-          ls.stop(`Failed to install ${srv.server} — you can install manually: ${srv.installCmd}`);
-        } else {
-          ls.stop(`${srv.server} installed`);
-        }
+  if (!isCancel(selected) && selected.length > 0) {
+    for (const srv of selected) {
+      if (isInstalled(srv.server)) {
+        note(`${srv.server} is already installed, skipping.`, srv.language);
+        continue;
+      }
+      const ls = spinner();
+      ls.start(`Installing ${srv.server}...`);
+      const [cmd, ...args] = srv.installCmd.split(" ");
+      const r = run(cmd, args);
+      if (r.status !== 0) {
+        ls.stop(`Failed to install ${srv.server} — you can install manually: ${srv.installCmd}`);
+      } else {
+        ls.stop(`${srv.server} installed`);
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "OMP-native workflow extension inspired by Superpowers.",
   "type": "module",
   "scripts": {

package/src/commands/config.ts

@@ -21,7 +21,7 @@ export function registerConfigCommand(pi: ExtensionAPI): void {
           `Max fix retries: ${config.orchestration.maxFixRetries}`,
           `Max nesting depth: ${config.orchestration.maxNestingDepth}`,
           `Model preference: ${config.orchestration.modelPreference}`,
-          `LSP auto-detect: ${config.lsp.autoDetect}`,
+          `LSP setup guide: ${config.lsp.setupGuide}`,
           `Notification verbosity: ${config.notifications.verbosity}`,
           `QA framework: ${config.qa.framework ?? "not detected"}`,
           `Release pipeline: ${config.release.pipeline ?? "not configured"}`,

package/src/config/defaults.ts

@@ -11,7 +11,6 @@ export const DEFAULT_CONFIG: SupipowersConfig = {
     modelPreference: "auto",
   },
   lsp: {
-    autoDetect: true,
     setupGuide: true,
   },
   notifications: {

package/src/config/schema.ts

@@ -13,7 +13,6 @@ const ConfigSchema = Type.Object({
     modelPreference: Type.String(),
   }),
   lsp: Type.Object({
-    autoDetect: Type.Boolean(),
     setupGuide: Type.Boolean(),
   }),
   notifications: Type.Object({

package/src/lsp/detector.ts

@@ -1,36 +1,31 @@
 // src/lsp/detector.ts
-import type { SupipowersConfig } from "../types.js";
+import { LSP_SERVERS, type LspServerEntry } from "./setup-guide.js";
 
-export interface LspStatus {
-  available: boolean;
-  servers: LspServerInfo[];
-}
-
-export interface LspServerInfo {
-  name: string;
-  status: "running" | "stopped" | "error";
-  fileTypes: string[];
-  error?: string;
+export interface LspServerStatus {
+  server: LspServerEntry;
+  installed: boolean;
 }
 
 /**
- * Check LSP availability by invoking the lsp tool's "status" action.
- * Uses pi.exec to call the lsp tool programmatically.
+ * Check which LSP servers are installed by looking for their binaries.
  */
-export async function detectLsp(
+export async function checkInstalledServers(
   exec: (cmd: string, args: string[]) => Promise<{ stdout: string; exitCode: number }>
-): Promise<LspStatus> {
-  try {
-    // We check by looking for LSP config files or running servers
-    // In OMP, LSP is a built-in tool — we check if it's in active tools
-    return { available: false, servers: [] };
-  } catch {
-    return { available: false, servers: [] };
+): Promise<LspServerStatus[]> {
+  const results: LspServerStatus[] = [];
+  for (const server of LSP_SERVERS) {
+    try {
+      const result = await exec("which", [server.server]);
+      results.push({ server, installed: result.exitCode === 0 });
+    } catch {
+      results.push({ server, installed: false });
+    }
   }
+  return results;
 }
 
 /**
- * Check if LSP is available from the extension context.
+ * Check if LSP is available from the OMP extension context at runtime.
  * Reads the active tools list to see if "lsp" is registered.
  */
 export function isLspAvailable(activeTools: string[]): boolean {

package/src/lsp/setup-guide.ts

@@ -1,13 +1,13 @@
 // src/lsp/setup-guide.ts
 
-export interface SetupInstruction {
+export interface LspServerEntry {
   language: string;
   server: string;
   installCommand: string;
   notes: string;
 }
 
-const COMMON_LSP_SERVERS: SetupInstruction[] = [
+export const LSP_SERVERS: LspServerEntry[] = [
   {
     language: "TypeScript/JavaScript",
     server: "typescript-language-server",
@@ -34,47 +34,16 @@ const COMMON_LSP_SERVERS: SetupInstruction[] = [
   },
 ];
 
-/** Get setup instructions for detected project languages */
-export function getSetupInstructions(detectedLanguages: string[]): SetupInstruction[] {
-  return COMMON_LSP_SERVERS.filter((s) =>
-    detectedLanguages.some((lang) =>
-      s.language.toLowerCase().includes(lang.toLowerCase())
-    )
-  );
-}
-
-/** Detect project languages from file extensions */
-export function detectProjectLanguages(files: string[]): string[] {
-  const extMap: Record<string, string> = {
-    ".ts": "typescript",
-    ".tsx": "typescript",
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".py": "python",
-    ".rs": "rust",
-    ".go": "go",
-    ".java": "java",
-    ".rb": "ruby",
-    ".php": "php",
-  };
-  const languages = new Set<string>();
-  for (const file of files) {
-    const ext = file.slice(file.lastIndexOf("."));
-    if (extMap[ext]) languages.add(extMap[ext]);
-  }
-  return [...languages];
-}
-
-/** Format setup instructions as readable text */
-export function formatSetupGuide(instructions: SetupInstruction[]): string {
-  if (instructions.length === 0) {
-    return "No LSP setup instructions available for your project languages.";
+/** Format all LSP servers as readable text */
+export function formatSetupGuide(servers: LspServerEntry[] = LSP_SERVERS): string {
+  if (servers.length === 0) {
+    return "No LSP servers available.";
   }
   const lines = ["LSP Setup Guide:", ""];
-  for (const inst of instructions) {
-    lines.push(`## ${inst.language} — ${inst.server}`);
-    lines.push(`Install: ${inst.installCommand}`);
-    lines.push(`Note: ${inst.notes}`);
+  for (const srv of servers) {
+    lines.push(`## ${srv.language} — ${srv.server}`);
+    lines.push(`Install: ${srv.installCommand}`);
+    lines.push(`Note: ${srv.notes}`);
     lines.push("");
   }
   return lines.join("\n");

package/src/types.ts

@@ -110,7 +110,6 @@ export interface SupipowersConfig {
     modelPreference: string;
   };
   lsp: {
-    autoDetect: boolean;
     setupGuide: boolean;
   };
   notifications: {