@montytools/cli 0.1.2 → 0.1.4

package/bin/monty.mjs

@@ -63,6 +63,7 @@ async function login() {
   mkdirSync(MONTY_HOME, { recursive: true });
   console.log(`logged-in: ${host} (key saved to ~/.monty/config.json)`);
   console.log(`apps home: ${MONTY_HOME}`);
+  installSkills({ silent: false });
 }
 
 // Loopback auth: serve one callback on 127.0.0.1, send the browser to
@@ -129,6 +130,79 @@ function openInBrowser(url) {
 }
 
 
+
+// ── agent skills ─────────────────────────────────────────────────────────────
+// The build skill ships inside this package. Primary installer is the
+// cross-agent standard `npx skills add` (same as InsForge) which fans out to
+// every agent's folder — Claude Code, Codex (.agents/skills), Cursor, etc.
+// Manual copy is the offline fallback. A version marker gates the work so
+// ordinary commands stay fast.
+const CLI_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const CLI_VERSION = JSON.parse(readFileSync(join(CLI_ROOT, "package.json"), "utf8")).version;
+const SKILLS_SRC = join(CLI_ROOT, "skills");
+const GLOBAL_SKILLS_MARKER = join(CONFIG_DIR, "skills-version");
+// InsForge's agent list — enumerate rather than '*' so we only touch real agents.
+const SKILL_AGENTS = ["antigravity", "augment", "claude-code", "cline", "codex", "cursor", "gemini-cli", "github-copilot", "kilo", "qoder", "qwen-code", "roo", "trae", "windsurf"]
+  .flatMap((a) => ["-a", a]);
+
+function readMarker(path) {
+  try {
+    return readFileSync(path, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+
+function skillsCliAdd({ global = false, cwd = undefined } = {}) {
+  const args = ["-y", "skills", "add", SKILLS_SRC, "-y", "--copy", ...(global ? ["-g"] : []), ...SKILL_AGENTS];
+  const res = spawnSync("npx", args, { cwd, stdio: "ignore", timeout: 120_000 });
+  return res.status === 0;
+}
+
+// Fallbacks for offline/npx-less environments: cover the two standard folders.
+function installSkillsInto(dir) {
+  if (!existsSync(SKILLS_SRC)) return;
+  for (const name of readdirSync(SKILLS_SRC)) {
+    cpSync(join(SKILLS_SRC, name), join(dir, name), { recursive: true });
+  }
+}
+
+function manualInstall(appDir) {
+  if (appDir) {
+    installSkillsInto(join(appDir, ".claude", "skills"));
+    installSkillsInto(join(appDir, ".agents", "skills"));
+  } else {
+    installSkillsInto(join(homedir(), ".claude", "skills"));
+    installSkillsInto(join(homedir(), ".agents", "skills"));
+  }
+}
+
+function installSkills({ appDir = null, silent = true, force = false } = {}) {
+  if (process.env.MONTY_NO_SKILLS) return;
+  try {
+    let changed = false;
+    if (force || readMarker(GLOBAL_SKILLS_MARKER) !== CLI_VERSION) {
+      if (!skillsCliAdd({ global: true })) manualInstall(null);
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(GLOBAL_SKILLS_MARKER, CLI_VERSION + "\n");
+      changed = true;
+    }
+    if (appDir) {
+      const marker = join(appDir, ".agents", "skills", "monty-build", "VERSION");
+      if (force || readMarker(marker) !== CLI_VERSION) {
+        if (!skillsCliAdd({ cwd: appDir })) manualInstall(appDir);
+        mkdirSync(dirname(marker), { recursive: true });
+        writeFileSync(marker, CLI_VERSION + "\n");
+        changed = true;
+      }
+    }
+    if (changed && !silent) console.log(`skills: installed for all agents (v${CLI_VERSION})`);
+    else if (changed) console.log(`skills: refreshed (v${CLI_VERSION})`);
+  } catch {
+    /* skills are best-effort — never block a command */
+  }
+}
+
 // ── monty current / select / apps ───────────────────────────────────────────
 // Folder management users never think about: every app lives in ~/Monty,
 // `current` says where you are, `select` prints the folder for cd $(...).
@@ -265,6 +339,7 @@ async function create() {
     console.log(`config: WARNING — could not reach ${host}/api/config; copy .env.example to .env.local manually`);
   }
 
+  installSkills({ appDir: target });
   console.log(`created: ${target}`);
   console.log(`next: cd ${target} && pnpm install && monty dev`);
 }
@@ -506,6 +581,9 @@ function walk(dir) {
 }
 
 // ── dispatch ───────────────────────────────────────────────────────────────
+// Keep agent skills fresh on every invocation (user level + current app).
+installSkills({ appDir: findAppRoot(process.cwd()) });
+
 switch (command) {
   case "login":
     await login();
@@ -535,11 +613,15 @@ switch (command) {
   case "apps":
     apps();
     break;
+  case "skills":
+    installSkills({ appDir: findAppRoot(process.cwd()), silent: false });
+    console.log("skills: up to date");
+    break;
   case "deploy":
     await deploy();
     break;
   default:
-    console.log("usage: monty <login|create|current|select|apps|dev|add|components|docs|deploy>");
+    console.log("usage: monty <login|create|current|select|apps|dev|add|components|docs|deploy|skills>");
     console.log("  login       [--host <url>] [--key <mk_...>]  sign in (opens your browser to authorize)");
     console.log("  create      <slug> [--name N] [--icon I]   stamp a new app into ~/Monty/<slug>");
     console.log("  dev         [--port 5173]                  run the app locally (sandboxed data)");
@@ -550,5 +632,6 @@ switch (command) {
     console.log("  select      <slug>                          print an app's folder — cd \"$(monty select x)\"");
     console.log("  apps                                        list local apps in ~/Monty");
     console.log("  deploy                                      build + upload this app");
+    console.log("  skills                                      install/refresh the agent build skill");
     process.exit(command ? 1 : 0);
 }

package/bin/postinstall.mjs

@@ -0,0 +1,42 @@
+// Best-effort: put the agent build skill where Claude Code looks for it
+// (~/.claude/skills) as soon as the package lands. Never fails the install;
+// set MONTY_NO_SKILLS=1 to opt out. `monty skills` re-runs this any time.
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+try {
+  if (process.env.MONTY_NO_SKILLS || process.env.CI) process.exit(0);
+  const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const src = join(root, "skills");
+  if (!existsSync(src)) process.exit(0);
+  const version = JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version;
+  const target = join(homedir(), ".claude", "skills");
+  mkdirSync(target, { recursive: true });
+  for (const name of readdirSync(src)) {
+    cpSync(join(src, name), join(target, name), { recursive: true });
+    writeFileSync(join(target, name, "VERSION"), version + "\n");
+  }
+  console.log(`monty: agent skill installed (~/.claude/skills, v${version})`);
+  // Codex: managed block in ~/.codex/AGENTS.md when Codex is present.
+  const codexDir = join(homedir(), ".codex");
+  const skillFile = join(src, "monty-build", "SKILL.md");
+  if (existsSync(codexDir) && existsSync(skillFile)) {
+    const body = readFileSync(skillFile, "utf8").replace(/^---[\s\S]*?---\n/, "").trim();
+    const START = "<!-- monty-build:start";
+    const END = "<!-- monty-build:end -->";
+    const block = `${START} v${version} -->\n${body}\n${END}`;
+    const file = join(codexDir, "AGENTS.md");
+    let cur = existsSync(file) ? readFileSync(file, "utf8") : "";
+    if (!cur.includes(`${START} v${version} -->`)) {
+      const re = new RegExp(`${START}[\\s\\S]*?${END}`);
+      cur = re.test(cur) ? cur.replace(re, block) : (cur ? cur.trimEnd() + "\n\n" : "") + block + "\n";
+      writeFileSync(file, cur);
+      console.log(`monty: agent contract added to ~/.codex/AGENTS.md (v${version})`);
+    }
+  }
+
+} catch {
+  /* silent — skills are a convenience, not a dependency */
+}

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@montytools/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "monty": "./bin/monty.mjs"
   },
   "files": [
     "bin",
-    "template"
+    "template",
+    "skills"
   ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
     "prepack": "node scripts/bundle-template.mjs",
-    "typecheck": "node --check bin/monty.mjs"
+    "typecheck": "node --check bin/monty.mjs",
+    "postinstall": "node bin/postinstall.mjs"
   },
   "dependencies": {
     "esbuild": "^0.28.1"

package/skills/monty-build/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: monty-build
+description: Build, run, and deploy Monty workspace apps. Use whenever the task involves a Monty app, monty.config.ts, the monty CLI (create/dev/deploy/add), the @montytools/sdk, or a prompt mentioning usemonty.dev. Covers folder discipline, the build loop, data/auth rules, and error handling.
+---
+
+# Building Monty apps
+
+Monty is a work OS: teams get internal apps built by coding agents. You write
+product logic only — data, auth, tenancy, deployment, and embedding are the
+platform's job. The complete contract lives in the app's own `AGENTS.md`
+(nearest-file-wins — read it before writing code). This skill is the map, not
+the territory.
+
+## Rules
+
+1. **Folders are managed.** Apps live in `~/Monty/<slug>`. `monty current`
+   tells you where you are; `cd "$(monty select <slug>)"` jumps to an app;
+   `monty apps` lists local ones. Never mkdir app folders by hand.
+2. **The loop:** `monty create <slug> --name "Name" --icon <lucide-icon>` →
+   edit `monty.config.ts` (zod tables) + `src/routes/` → verify with
+   `monty dev` (localhost:5173, already authenticated, sandboxed data) →
+   `monty deploy`. You are done when deploy prints the URL.
+3. **One import surface:** `@montytools/sdk` (`defineApp`, zod) and
+   `@montytools/sdk/react` (hooks: `useList`, `useInsert`, …). Never import
+   Clerk or Convex directly; never fetch external APIs from app code — the
+   platform CSP blocks them.
+4. **Schema is zod in `monty.config.ts`.** Field names `_*`, `updatedAt`,
+   `createdBy` are reserved. Push happens automatically on dev/deploy.
+5. **UI is stock shadcn** (preset already wired). Add curated components with
+   `monty add <name>`; browse with `monty components` / `monty docs <name>`.
+6. **Errors are instructions.** Every failure prints
+   `[MontyError CODE] Fix: …` — do exactly what the Fix says; don't guess.
+   Typecheck failures block deploy by design.
+7. **Verify before deploy.** `monty dev` writes to a `#dev` sandbox — live
+   team records are never touched, so exercise the app for real.
+
+## CLI reference
+
+| command | purpose |
+|---|---|
+| `monty login` | browser sign-in (loopback authorize), once per machine |
+| `monty create <slug>` | stamp a new app into `~/Monty/<slug>` |
+| `monty current` / `select` / `apps` | where am I / jump to app / list local |
+| `monty dev` | run locally on :5173, sandboxed data, auto-auth |
+| `monty add <name…>` | install curated shadcn components |
+| `monty deploy` | build + typecheck + upload; app appears in the workspace |
+| `monty skills` | (re)install this skill for your agent |