@mushi-mushi/cli 0.2.0 → 0.5.0

package/README.md

@@ -1,25 +1,74 @@
 # @mushi-mushi/cli
 
-CLI tool for Mushi Mushi project management and report triage.
+CLI for Mushi Mushi — set up the SDK in one command, then triage reports and monitor the pipeline from your terminal.
 
-## Install
+## One-command setup
+
+```bash
+npx @mushi-mushi/cli init
+# equivalently:
+npx mushi-mushi
+```
+
+The wizard:
+
+1. Detects your framework (Next.js, Nuxt, SvelteKit, Angular, Expo, Capacitor, plain React/Vue/Svelte, or vanilla JS) from `package.json` and config files.
+2. Picks the right SDK package (`@mushi-mushi/react`, `@mushi-mushi/vue`, etc.) plus `@mushi-mushi/web` when the framework SDK is API-only.
+3. Detects your package manager (npm / pnpm / yarn / bun) from your lockfile and installs with that — `shell: false`, with Windows `.cmd` shim resolution.
+4. Writes `MUSHI_PROJECT_ID` and `MUSHI_API_KEY` (with the right framework prefix — `NEXT_PUBLIC_`, `NUXT_PUBLIC_`, `VITE_`) to `.env.local` (or `.env`).
+5. Warns you if `.env.local` isn't in `.gitignore` (covers `.env*.local`, `*.local`, etc.).
+6. Prints the framework-specific provider snippet to copy-paste.
+7. Offers to **send a real test report** so you see your first classified bug in the console immediately. Opt out via `--skip-test-report`.
+
+It never silently overwrites existing env vars or modifies application code. Pasted credentials are sanitized (stripped of quotes / CR / LF / NUL) and validated against `^proj_[A-Za-z0-9_-]{10,}$` / `^mushi_[A-Za-z0-9_-]{10,}$` before anything is written to disk.
+
+### Flags
+
+```bash
+mushi init --framework next                             # skip framework detection
+mushi init --project-id proj_xxx --api-key mushi_xxx    # skip credential prompts
+mushi init --skip-install                               # print the install command instead
+mushi init --skip-test-report                           # don't offer to send a test report
+mushi init --cwd apps/web                               # run in a sub-package of a monorepo
+mushi init --endpoint https://mushi.your-company.com    # self-hosted Mushi API
+mushi init -y                                           # accept the detected framework
+```
+
+Non-interactive use (CI): pass `--yes --project-id proj_xxx --api-key mushi_xxx` or the wizard exits with a clear error instead of hanging on a prompt.
+
+Stale-version hint: the wizard checks the npm registry (2s timeout) and prints a one-line upgrade nudge if a newer stable is published. Opt out with `MUSHI_NO_UPDATE_CHECK=1`.
+
+Monorepo awareness: if you run the wizard at a workspace root with no framework dep, it scans `apps/*`, `packages/*`, `examples/*` and tells you which sub-package you probably meant (`mushi init --cwd apps/web`).
+
+## Install globally
 
 ```bash
 npm install -g @mushi-mushi/cli
+mushi --help
+mushi --version
 ```
 
-## Usage
+## Other commands
 
 ```bash
-mushi login              # Authenticate with your API key
-mushi status             # Project overview
-mushi reports list       # List recent reports
-mushi reports show <id>  # View report details
-mushi reports triage <id> --priority high --assign @dev
-mushi deploy check       # Check edge function health
-mushi test               # Submit a test report to verify pipeline
+mushi login --api-key mushi_xxx     # store credentials in ~/.mushirc (mode 0o600)
+mushi status                         # project overview
+mushi reports list                   # recent reports
+mushi reports show <id>              # one report
+mushi reports triage <id> --status acknowledged --severity high
+mushi deploy check                   # edge-function health probe
+mushi index <path>                   # walk a local repo and feed RAG
+mushi test                           # submit a test report end-to-end
+mushi config endpoint https://...    # set API endpoint (https:// required outside localhost)
 ```
 
+## Security notes
+
+- `~/.mushirc` is written with mode `0o600` on Unix. Legacy configs with looser permissions are tightened on load.
+- `--endpoint` values are parsed through `new URL()` and required to use `https://` except for `localhost` / `127.0.0.1` / `*.local`.
+- The `--api-key` flag leaks into `ps -ef` — prefer the interactive prompt on shared machines.
+- Full stack traces on error: `DEBUG=mushi mushi init`.
+
 ## License
 
 MIT

package/dist/chunk-I3FFGUE5.js

@@ -0,0 +1,6 @@
+// src/version.ts
+var MUSHI_CLI_VERSION = true ? "0.5.0" : "0.0.0-dev";
+
+export {
+  MUSHI_CLI_VERSION
+};

package/dist/chunk-ZZNVMBMG.js

@@ -0,0 +1,256 @@
+// src/detect.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var FRAMEWORK_IDS = [
+  "next",
+  "react",
+  "vue",
+  "nuxt",
+  "svelte",
+  "sveltekit",
+  "angular",
+  "expo",
+  "react-native",
+  "capacitor",
+  "vanilla"
+];
+function isFrameworkId(value) {
+  return typeof value === "string" && FRAMEWORK_IDS.includes(value);
+}
+var FRAMEWORKS = {
+  next: {
+    id: "next",
+    label: "Next.js",
+    packageName: "@mushi-mushi/react",
+    needsWebPackage: false,
+    snippet: (apiKey, projectId) => `// app/providers.tsx (or pages/_app.tsx for /pages router)
+'use client'
+import { MushiProvider } from '@mushi-mushi/react'
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <MushiProvider config={{
+      projectId: '${projectId}',
+      apiKey: '${apiKey}',
+    }}>
+      {children}
+    </MushiProvider>
+  )
+}`
+  },
+  react: {
+    id: "react",
+    label: "React",
+    packageName: "@mushi-mushi/react",
+    needsWebPackage: false,
+    snippet: (apiKey, projectId) => `// src/main.tsx
+import { MushiProvider } from '@mushi-mushi/react'
+
+createRoot(document.getElementById('root')!).render(
+  <MushiProvider config={{
+    projectId: '${projectId}',
+    apiKey: '${apiKey}',
+  }}>
+    <App />
+  </MushiProvider>
+)`
+  },
+  vue: {
+    id: "vue",
+    label: "Vue 3",
+    packageName: "@mushi-mushi/vue",
+    needsWebPackage: true,
+    snippet: (apiKey, projectId) => `// src/main.ts
+import { MushiPlugin } from '@mushi-mushi/vue'
+import { Mushi } from '@mushi-mushi/web'
+
+app.use(MushiPlugin, { projectId: '${projectId}', apiKey: '${apiKey}' })
+Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })`
+  },
+  nuxt: {
+    id: "nuxt",
+    label: "Nuxt",
+    packageName: "@mushi-mushi/vue",
+    needsWebPackage: true,
+    snippet: (apiKey, projectId) => `// plugins/mushi.client.ts
+import { MushiPlugin } from '@mushi-mushi/vue'
+import { Mushi } from '@mushi-mushi/web'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.use(MushiPlugin, {
+    projectId: '${projectId}',
+    apiKey: '${apiKey}',
+  })
+  Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })
+})`
+  },
+  svelte: {
+    id: "svelte",
+    label: "Svelte",
+    packageName: "@mushi-mushi/svelte",
+    needsWebPackage: true,
+    snippet: (apiKey, projectId) => `// src/main.ts (or +layout.svelte for SvelteKit)
+import { initMushi } from '@mushi-mushi/svelte'
+import { Mushi } from '@mushi-mushi/web'
+
+initMushi({ projectId: '${projectId}', apiKey: '${apiKey}' })
+Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })`
+  },
+  sveltekit: {
+    id: "sveltekit",
+    label: "SvelteKit",
+    packageName: "@mushi-mushi/svelte",
+    needsWebPackage: true,
+    snippet: (apiKey, projectId) => `// src/routes/+layout.svelte
+<script>
+  import { onMount } from 'svelte'
+  import { initMushi } from '@mushi-mushi/svelte'
+
+  onMount(async () => {
+    const { Mushi } = await import('@mushi-mushi/web')
+    initMushi({ projectId: '${projectId}', apiKey: '${apiKey}' })
+    Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })
+  })
+</script>`
+  },
+  angular: {
+    id: "angular",
+    label: "Angular",
+    packageName: "@mushi-mushi/angular",
+    needsWebPackage: true,
+    snippet: (apiKey, projectId) => `// src/main.ts
+import { provideMushi } from '@mushi-mushi/angular'
+import { Mushi } from '@mushi-mushi/web'
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideMushi({ projectId: '${projectId}', apiKey: '${apiKey}' }),
+  ],
+})
+Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })`
+  },
+  expo: {
+    id: "expo",
+    label: "Expo",
+    packageName: "@mushi-mushi/react-native",
+    needsWebPackage: false,
+    snippet: (apiKey, projectId) => `// App.tsx
+import { MushiProvider } from '@mushi-mushi/react-native'
+
+export default function App() {
+  return (
+    <MushiProvider projectId="${projectId}" apiKey="${apiKey}">
+      <YourApp />
+    </MushiProvider>
+  )
+}`
+  },
+  "react-native": {
+    id: "react-native",
+    label: "React Native",
+    packageName: "@mushi-mushi/react-native",
+    needsWebPackage: false,
+    snippet: (apiKey, projectId) => `// App.tsx
+import { MushiProvider } from '@mushi-mushi/react-native'
+
+export default function App() {
+  return (
+    <MushiProvider projectId="${projectId}" apiKey="${apiKey}">
+      <YourApp />
+    </MushiProvider>
+  )
+}`
+  },
+  capacitor: {
+    id: "capacitor",
+    label: "Capacitor (Ionic)",
+    packageName: "@mushi-mushi/capacitor",
+    needsWebPackage: false,
+    snippet: (apiKey, projectId) => `// src/main.ts
+import { Mushi } from '@mushi-mushi/capacitor'
+
+Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })`
+  },
+  vanilla: {
+    id: "vanilla",
+    label: "Vanilla JS / unknown",
+    packageName: "@mushi-mushi/web",
+    needsWebPackage: false,
+    snippet: (apiKey, projectId) => `// Anywhere in your client bundle
+import { Mushi } from '@mushi-mushi/web'
+
+Mushi.init({ projectId: '${projectId}', apiKey: '${apiKey}' })`
+  }
+};
+function readPackageJson(cwd) {
+  const path = join(cwd, "package.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectFramework(cwd, pkg) {
+  const deps = collectDeps(pkg);
+  if (deps.has("next")) return FRAMEWORKS.next;
+  if (deps.has("nuxt")) return FRAMEWORKS.nuxt;
+  if (deps.has("@sveltejs/kit")) return FRAMEWORKS.sveltekit;
+  if (deps.has("@angular/core")) return FRAMEWORKS.angular;
+  if (deps.has("expo")) return FRAMEWORKS.expo;
+  if (deps.has("react-native")) return FRAMEWORKS["react-native"];
+  if (deps.has("@capacitor/core")) return FRAMEWORKS.capacitor;
+  if (deps.has("svelte")) return FRAMEWORKS.svelte;
+  if (deps.has("vue")) return FRAMEWORKS.vue;
+  if (deps.has("react")) return FRAMEWORKS.react;
+  if (existsSync(join(cwd, "next.config.js")) || existsSync(join(cwd, "next.config.ts"))) {
+    return FRAMEWORKS.next;
+  }
+  if (existsSync(join(cwd, "nuxt.config.ts")) || existsSync(join(cwd, "nuxt.config.js"))) {
+    return FRAMEWORKS.nuxt;
+  }
+  if (existsSync(join(cwd, "svelte.config.js"))) return FRAMEWORKS.svelte;
+  if (existsSync(join(cwd, "angular.json"))) return FRAMEWORKS.angular;
+  return FRAMEWORKS.vanilla;
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(cwd, "package-lock.json"))) return "npm";
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  return "npm";
+}
+function installCommand(pm, packages) {
+  const verb = pm === "npm" ? "install" : "add";
+  return `${pm} ${verb} ${packages.join(" ")}`;
+}
+function envVarsToWrite(apiKey, projectId, framework) {
+  const prefix = framework.id === "next" ? "NEXT_PUBLIC_" : framework.id === "nuxt" ? "NUXT_PUBLIC_" : "VITE_";
+  return [
+    `${prefix}MUSHI_PROJECT_ID=${projectId}`,
+    `${prefix}MUSHI_API_KEY=${apiKey}`
+  ].join("\n");
+}
+function collectDeps(pkg) {
+  if (!pkg) return /* @__PURE__ */ new Set();
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {})
+  ]);
+}
+
+export {
+  FRAMEWORK_IDS,
+  isFrameworkId,
+  FRAMEWORKS,
+  readPackageJson,
+  detectFramework,
+  detectPackageManager,
+  installCommand,
+  envVarsToWrite
+};

package/dist/detect.d.ts

@@ -0,0 +1,30 @@
+/**
+ * FILE: packages/cli/src/detect.ts
+ * PURPOSE: Pure detection helpers for framework, package manager, and project state.
+ *          Kept side-effect-free so the wizard remains unit-testable.
+ */
+type FrameworkId = 'next' | 'react' | 'vue' | 'nuxt' | 'svelte' | 'sveltekit' | 'angular' | 'expo' | 'react-native' | 'capacitor' | 'vanilla';
+interface Framework {
+    id: FrameworkId;
+    label: string;
+    packageName: string;
+    needsWebPackage: boolean;
+    snippet: (apiKey: string, projectId: string) => string;
+}
+interface PackageJson {
+    name?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+declare const FRAMEWORK_IDS: ReadonlyArray<FrameworkId>;
+declare function isFrameworkId(value: unknown): value is FrameworkId;
+declare const FRAMEWORKS: Record<FrameworkId, Framework>;
+declare function readPackageJson(cwd: string): PackageJson | null;
+declare function detectFramework(cwd: string, pkg: PackageJson | null): Framework;
+declare function detectPackageManager(cwd: string): PackageManager;
+declare function installCommand(pm: PackageManager, packages: string[]): string;
+declare function envVarsToWrite(apiKey: string, projectId: string, framework: Framework): string;
+
+export { FRAMEWORKS, FRAMEWORK_IDS, type Framework, type FrameworkId, type PackageJson, type PackageManager, detectFramework, detectPackageManager, envVarsToWrite, installCommand, isFrameworkId, readPackageJson };

package/dist/detect.js

@@ -0,0 +1,20 @@
+import {
+  FRAMEWORKS,
+  FRAMEWORK_IDS,
+  detectFramework,
+  detectPackageManager,
+  envVarsToWrite,
+  installCommand,
+  isFrameworkId,
+  readPackageJson
+} from "./chunk-ZZNVMBMG.js";
+export {
+  FRAMEWORKS,
+  FRAMEWORK_IDS,
+  detectFramework,
+  detectPackageManager,
+  envVarsToWrite,
+  installCommand,
+  isFrameworkId,
+  readPackageJson
+};