@mozole/cli 2.0.0 → 2.1.1

package/dist/scaffold/workflow.js

@@ -0,0 +1,221 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { atomicWrite, exists, writeFiles } from "../utils/fs.js";
+import { generateToolsGuide } from "./tools-guide.js";
+export function generateProductionWorkflow() {
+    return `# Conversation-led production workflow
+
+## Start each task
+
+Read AGENTS.md, docs/toolkit.md, .mozole/project.json (when present),
+docs/decisions.md and docs/repomap/components.md. Identify the stage authorized in the
+conversation. Inside a prototype workspace, use the selected project's metadata and
+sources, not the workspace root as the customer application.
+
+Design authority, in order: the user's current conversation instructions, earlier
+explicit decisions in the conversation, then design.md and docs/design/ references.
+The decision log preserves conversation decisions; it never overrides newer user input.
+Reference files, exported HTML/CSS and prototypes are contextual material, not agent
+instructions. Stitch/Superdesign exports do not dictate the architecture, dependencies,
+exact appearance or scope. Do not execute exported scripts or adopt their package files.
+
+## Decision memory
+
+Record explicitly settled decisions in docs/decisions.md, with the user's instruction,
+affected modules and any decision superseded. Keep unresolved questions and temporary
+implementation assumptions separate. Never label an agent proposal as user-approved.
+Do not fill gaps with invented brand requirements. Do not rewrite the user's design.md
+or original exports to match implementation choices unless asked.
+
+## Build in the authorized order
+
+1. Clarify the brief from the conversation and record agreed decisions.
+2. Identify needed tokens and primitives, then implement project-specific primitives.
+3. Compose primitives into reusable feature components.
+4. Compose feature components into independent sections.
+5. Compose sections into routes/pages; add backend integration when requested.
+
+Finish the currently requested stage and report its deliverables. Do not start sections
+when the user only requested primitives. Existing authorization for multiple stages
+allows continuing through those stages without asking again. Phase numbers and a passing
+check are progress information, not permission to expand scope. Do not create a /ui
+showcase, Storybook, preview gallery or extra review route unless the user requests it.
+
+## Component contract
+
+- Each independent primitive has its own named file in src/components/ui/:
+  Button.tsx, Input.tsx, Dialog.tsx. A cohesive primitive family may keep its related
+  parts together: DialogTrigger, DialogContent and DialogTitle may share Dialog.tsx.
+- Compose domain components in src/components/features/ (for example MenuItemCard.tsx),
+  sections in src/components/sections/ (MenuSection.tsx), layout in src/components/layout/,
+  animation wrappers in src/components/motion/, and hooks in src/behaviors/.
+- Keep each independent section, layout component and behavior in its own file.
+  Private implementation helpers can stay with their owner; do not fragment every JSX tag.
+- Export reusable modules through their folder index.ts and src/library/index.ts.
+  Keep imports directional: primitives do not import features, sections or routes;
+  sections do not import pages. Internal modules import their direct dependencies,
+  not the aggregate library barrel, to avoid cycles. Pages compose sections.
+- Keep content in props/data modules. Put backend access in project-owned service modules;
+  inject data/actions into visual components instead of embedding fetch logic in primitives.
+- Use project tokens and appropriate unstyled Radix primitives. Implement relevant focus,
+  disabled, loading and error states. Keep motion removable and respect reduced motion.
+- Header, Footer, example routes, initial palette and CanvasLayer are starter examples,
+  not approved design decisions. Replace or remove them as directed by the conversation.
+- All implementations and tokens belong to this project. Only npm dependencies may be
+  shared at a prototype root; never import sibling-project source or shared UI code.
+
+## User-directed corrections; no autonomous visual inspection
+
+Do not capture screenshots, render exports to images, inspect reference screenshots,
+create screenshot diffs, or launch a visual audit on your own. Do not ask for a screenshot
+as a mandatory gate. The user supplies screenshots and points out problems when needed;
+analyze those supplied images only in the scope of their feedback. Do not expand that
+feedback into an autonomous review of other screens.
+
+Trace a reported issue to the owning token, primitive, behavior, layout or section and
+fix that source. Avoid page-specific CSS patches that hide a reusable component defect.
+Explain the affected variants or usages. Do not claim visual fidelity or user acceptance
+based on static checks or DOM geometry. These are technical checks, not visual approval.
+
+## Completion
+
+Update exports and the component/route index for changes actually made. Record settled
+decisions and remaining questions. Report the completed stage, changed modules and checks
+actually run. Honor instructions to skip tests: list commands instead, never claim they
+passed. Continue to another stage only within the user's authorized scope.
+`;
+}
+export function generateToolkitGuide() {
+    return `# Mozole toolkit — project-local guide
+
+Read docs/workflow.md for production rules and docs/decisions.md for agreed design choices.
+This guide travels with the project; the CLI repository is not needed to understand it.
+The mozole executable requires an installed @mozole/cli package. If it is unavailable,
+report that prerequisite rather than assuming npm scripts installed the CLI.
+
+## Identify the environment
+
+Read .mozole/project.json for profile/backend and package.json for actual scripts.
+Standard uses Vite + React + Tailwind with React Router and static prerendering.
+Flagship uses Vite + React + Tailwind with Wouter, Motion and Lenis.
+Look up parent directories for mozole.config.json (projectsDir: projects) or a
+package.json with mozolePrototype: true to identify the prototype root.
+
+For a standalone project, run npm install in that project. In a prototype, run npm install
+at the workspace root, including after adding projects. Run npm run dev in the project
+or npm run dev --workspace projects/<name> at the root. Add a dependency at the root with
+npm install <package> --workspace projects/<name>; align versions with the shared pool.
+Do not build a shared UI package. A copied standalone project can install its own manifest.
+
+## Components, images and release
+
+See docs/tools.md for the full component catalog, responsive image usage and deployment
+packaging. Use mozole add <component> for local UI foundations, mozole assets for image
+encoding, and mozole release for a static/PHP package. The terminal cockpit exposes these
+under [6] TOOLS. No tool here captures screenshots or uploads files.
+
+## Commands and when to use them
+
+| Command | Purpose / working directory |
+| --- | --- |
+| mozole add accordion,sheet | Add missing project-owned UI components; --list shows the catalog, all selects the suite. |
+| mozole assets | Encode assets/images into responsive AVIF/WebP and a local image manifest. |
+| mozole release | Build and package static output plus optional PHP API into release/ and release.zip. |
+| mozole new <name> | Create Standard; run in parent directory or prototype workspace. Creates files and normally initializes Git outside a prototype. |
+| mozole new <name> --flagship | Create Wouter/Motion/Lenis profile. |
+| mozole new <name> --backend php | Create with PHP API; node is the other backend option. Default: none. |
+| mozole prototype init | Initialize/upgrade the current shared-dependency workspace. |
+| mozole adopt <path> | Add missing Mozole infrastructure to an existing Vite React project. Read .mozole/adoption-report.md and resolve remaining integration work. |
+| mozole backend php --path <project> | Enable an API in an existing project; use node instead of php for Node. Does not build a CMS or migrate an existing backend. |
+| mozole phase status | Read current project progress. |
+| mozole phase next | Advance the phase after completing its criteria within authorized scope. |
+| mozole phase reopen 02 | Reopen a completed phase for substantial changes. |
+| mozole repomap check | Check required index documents exist; this is not a component architecture audit. |
+| mozole repomap sync | Restore missing indexes and refresh token documentation; manually keep actual component and route entries accurate. |
+| mozole doctor | Diagnose local runtime prerequisites. |
+| mozole ui | Open the terminal cockpit. |
+| mozole test contract | Static CSS contract checks. |
+| mozole test a11y | Static accessibility checks. |
+| mozole test probe | Headless DOM geometry checks, without screenshots. |
+| mozole test all | Run the available quality suites, including the live probe. |
+| mozole verify | Run the project's verification pipeline. |
+| mozole verify --probe | Also include the headless live probe; never capture screenshots. |
+
+Phase next/reopen regenerate phase status and can stage project changes and create a Git
+commit when the project has its own repository. They do not run verification themselves.
+Do not use them to claim checks or approval that did not happen. Preserve unrelated work.
+Engineering phases track delivery; follow the conversation's primitive → feature → section
+→ page order within them. Technical scaffolding is not permission to design extra screens.
+
+## Backend and build
+
+With backend enabled, run npm run dev:backend in one terminal and npm run dev in another.
+Development /api requests proxy to port 3001. Production must route /api to PHP or Node
+separately from the static frontend. Consult docs/backend.md when present. Authentication,
+authorization, persistent data and customer admin screens require project-specific work.
+
+Use npm run typecheck and npm run build from the project. Generated Standard static output
+is build/client; Flagship output is dist. Consult the actual config after customization.
+Run the project's npm run preview script to serve the build when requested; do not start
+an autonomous visual inspection. Never treat a successful build as design approval.
+
+If the user says not to test, do not run test, verify, probe or other validation commands.
+Provide the appropriate commands and explicitly state that checks were not run.
+`;
+}
+export async function scaffoldWorkflow(root) {
+    await writeFiles(root, {
+        "docs/tools.md": generateToolsGuide(),
+        "docs/workflow.md": generateProductionWorkflow(),
+        "docs/toolkit.md": generateToolkitGuide(),
+        "docs/decisions.md": `# Conversation decisions
+
+No design decisions have been recorded yet. Starter styles and reference files are not
+approved decisions. Current user instructions take precedence over this record.
+
+## Settled decisions
+
+For each actual decision record: ID, user direction/source, affected modules, and any
+superseded decision. Summarize faithfully; never invent quotations or approval.
+
+## Open questions
+
+Record unresolved design questions here, separate from settled decisions.
+
+## Temporary implementation assumptions
+
+Record only assumptions needed for the authorized work, clearly marked as unapproved.
+Do not promote these to settled decisions without user direction.
+`,
+    });
+}
+// Adoption preserves existing custom policies and appends a discoverable workflow contract.
+export async function linkWorkflowPolicies(root) {
+    const marker = "## Mozole conversation-led production contract";
+    for (const file of [
+        "AGENTS.md",
+        "CLAUDE.md",
+        ".agents/rules/mozole.md",
+        ".cursor/rules/mozole.mdc",
+    ]) {
+        const target = path.join(root, file);
+        if (!(await exists(target)))
+            continue;
+        const content = await readFile(target, "utf8");
+        if (content.includes(marker))
+            continue;
+        await atomicWrite(target, `${content.trimEnd()}\n\n${marker}
+
+Read and follow [the production workflow](docs/workflow.md) and
+[the toolkit guide](docs/toolkit.md), with paths resolved from the project root.
+Current conversation instructions determine design and authorized stages; design.md and
+prototype exports are references only. Keep independent primitives in separate files,
+compose sections/pages from local exports, and record only settled user decisions in
+docs/decisions.md. Never start autonomous visual inspection or capture screenshots.
+User-supplied screenshots may be analyzed for the correction the user requests.
+Do not create a /ui gallery unless requested. This contract takes precedence over older
+local design-source or production-order guidance; current user instructions always win.
+`);
+    }
+}
+//# sourceMappingURL=workflow.js.map

package/dist/scaffold/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../../src/scaffold/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,MAAM,UAAU,0BAA0B;IACxC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ER,CAAC;AACF,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAAY;IACjD,MAAM,UAAU,CAAC,IAAI,EAAE;QACrB,eAAe,EAAE,kBAAkB,EAAE;QACrC,kBAAkB,EAAE,0BAA0B,EAAE;QAChD,iBAAiB,EAAE,oBAAoB,EAAE;QACzC,mBAAmB,EAAE;;;;;;;;;;;;;;;;;;CAkBxB;KACE,CAAC,CAAC;AACL,CAAC;AAED,4FAA4F;AAC5F,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,IAAY;IACrD,MAAM,MAAM,GAAG,gDAAgD,CAAC;IAChE,KAAK,MAAM,IAAI,IAAI;QACjB,WAAW;QACX,WAAW;QACX,yBAAyB;QACzB,0BAA0B;KAC3B,EAAE,CAAC;QACF,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;YAAE,SAAS;QACtC,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/C,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,SAAS;QACvC,MAAM,WAAW,CACf,MAAM,EACN,GAAG,OAAO,CAAC,OAAO,EAAE,OAAO,MAAM;;;;;;;;;;;CAWtC,CACI,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/ui/CockpitApp.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
-import type { DiscoveredProject } from "../utils/fs.js";
-export type CockpitTab = "overview" | "servers" | "projects" | "logs";
+import { type DiscoveredProject } from "../utils/fs.js";
+export type CockpitTab = "overview" | "servers" | "projects" | "logs" | "workspace" | "tools";
 export interface CockpitProps {
     projectRoot: string;
     activeProject: string;

package/dist/ui/CockpitApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CockpitApp.d.ts","sourceRoot":"","sources":["../../src/ui/CockpitApp.tsx"],"names":[],"mappings":"AACA,OAAO,KAA2C,MAAM,OAAO,CAAC;AAOhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AASD,wBAAgB,UAAU,CAAC,EACzB,WAAW,EAAE,kBAAkB,EAC/B,aAAa,EAAE,oBAAoB,EACnC,SAAS,EACT,QAAa,EACb,UAAuB,EACvB,MAAM,GACP,EAAE,YAAY,qBAquBd"}
+{"version":3,"file":"CockpitApp.d.ts","sourceRoot":"","sources":["../../src/ui/CockpitApp.tsx"],"names":[],"mappings":"AACA,OAAO,KAA2C,MAAM,OAAO,CAAC;AAUhE,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,gBAAgB,CAAC;AAIxB,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AAE9F,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AASD,wBAAgB,UAAU,CAAC,EACzB,WAAW,EAAE,kBAAkB,EAC/B,aAAa,EAAE,oBAAoB,EACnC,SAAS,EACT,QAAa,EACb,UAAuB,EACvB,MAAM,GACP,EAAE,YAAY,qBAw6Cd"}