leglas 0.1.0

package/dist/init.d.ts

@@ -0,0 +1,13 @@
+import type { Write } from "./new.js";
+export declare const AGENTS_MARKER_START = "<!-- leglas:start -->";
+export declare const AGENTS_MARKER_END = "<!-- leglas:end -->";
+export type InitPlan = {
+    writes: Write[];
+    gitignore: string | null;
+};
+export declare function planInit(options: {
+    agents: string | null;
+    config: string | null;
+    gitignore: string | null;
+    force?: boolean;
+}): InitPlan;

package/dist/keep.d.ts

@@ -0,0 +1,32 @@
+import { type Preview } from "@leglas/server";
+export type KeepPlan = {
+    ok: true;
+    move: {
+        from: string;
+        to: string;
+    };
+    removeDir: string;
+    dropTitles: string[];
+    exportName: string;
+    instructions: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Plan the end of an exploration.
+ *
+ * Exploring is only safe to start because finishing is cheap, and finishing
+ * means the winner leaves the ignored directory for real source while the
+ * alternatives disappear entirely. Leglas can do this only because it knows
+ * where it put those files; anything it did not generate is refused rather than
+ * guessed at.
+ *
+ * The one step left to the user is the import in their own component, for the
+ * same reason `leglas new` prints it rather than applying it.
+ */
+export declare function planKeep(options: {
+    title: string;
+    previews: readonly Preview[];
+    to: string;
+}): KeepPlan;

package/dist/new.d.ts

@@ -0,0 +1,34 @@
+export type Framework = "next" | "react";
+export type Write = {
+    path: string;
+    contents: string;
+};
+export type NewPlan = {
+    writes: Write[];
+    /** New .gitignore contents, or null when no change is needed. */
+    gitignore: string | null;
+    previews: {
+        title: string;
+        url: string;
+    }[];
+    instructions: string;
+};
+/**
+ * Which shape of param reading to generate. Only the distinction that changes
+ * the output is drawn: whether params arrive on the server as a prop, or are
+ * read from the URL in the browser. The browser form is the fallback because
+ * it works anywhere React does.
+ */
+export declare function detectFramework(packageJson: string | null): Framework;
+/** The surface name becomes a query param, so it has to survive a URL intact. */
+export declare function surfaceSlug(surface: string): string;
+export declare function planNew(options: {
+    surface: string;
+    packageJson: string | null;
+    gitignore: string | null;
+    /** An existing component to use as the baseline, instead of a placeholder. */
+    from?: {
+        path: string;
+        contents: string;
+    } | undefined;
+}): NewPlan;

package/dist/run-classify.d.ts

@@ -0,0 +1,14 @@
+import type { ClassifyChange } from "./args.js";
+import type { PreviewDeps, PreviewResult } from "./run-previews.js";
+/**
+ * Answer where a direction should live, before it is written.
+ *
+ * Both answers are successes: the point is to be asked, so an agent about to
+ * change dependencies or rewrite a shared file learns the checkout route
+ * instead of quietly costing the property that makes flipping instant.
+ */
+export declare function runClassify(options: {
+    changes: ClassifyChange[];
+    json: boolean;
+    cwd: string;
+}, deps: PreviewDeps): Promise<PreviewResult>;

package/dist/run-explore.d.ts

@@ -0,0 +1,18 @@
+export type ExploreDeps = {
+    log(line: string): void;
+};
+/**
+ * Hand an agent several genuinely different angles at once.
+ *
+ * Leglas runs no model, so orchestration here means divergence pressure rather
+ * than inference: the value added over "give me six variants" is that the six
+ * are told to disagree, and told which obvious reading would make them
+ * converge.
+ */
+export declare function runExplore(options: {
+    surface: string;
+    count: number;
+    json: boolean;
+}, deps: ExploreDeps): {
+    exitCode: number;
+};

package/dist/run-init.d.ts

@@ -0,0 +1,16 @@
+export type InitDeps = {
+    log(line: string): void;
+};
+/**
+ * Prepare a project: an AGENTS.md section so any agent entering the repo knows
+ * how to author directions, a starter config, and the ignore entry. Adopting
+ * Leglas in a repository is what distributes the contract; nothing has to be
+ * installed per user.
+ */
+export declare function runInit(options: {
+    cwd: string;
+    force: boolean;
+    json: boolean;
+}, deps: InitDeps): Promise<{
+    exitCode: number;
+}>;

package/dist/run-keep.d.ts

@@ -0,0 +1,12 @@
+export type KeepDeps = {
+    log(line: string): void;
+    error(line: string): void;
+};
+export declare function runKeep(options: {
+    title: string;
+    to: string;
+    json: boolean;
+    cwd: string;
+}, deps: KeepDeps): Promise<{
+    exitCode: number;
+}>;

package/dist/run-new.d.ts

@@ -0,0 +1,23 @@
+export type NewDeps = {
+    log(line: string): void;
+};
+export type NewResult = {
+    exitCode: number;
+    written: string[];
+};
+/**
+ * Scaffold a branch point for a surface.
+ *
+ * Writes only into the gitignored directory and, at most, appends one line to
+ * .gitignore. The single change to the user's own source is printed rather
+ * than applied: rewriting somebody's component automatically is how a tool
+ * breaks a codebase it does not understand, and a wrong edit there costs far
+ * more than a line of copying.
+ */
+export declare function runNew(options: {
+    surface: string;
+    print: boolean;
+    json: boolean;
+    from?: string | undefined;
+    cwd: string;
+}, deps: NewDeps): Promise<NewResult>;

package/dist/run-previews.d.ts

@@ -0,0 +1,28 @@
+import type { AddPreview } from "./args.js";
+export type PreviewDeps = {
+    log(line: string): void;
+    error(line: string): void;
+};
+export type PreviewResult = {
+    exitCode: number;
+};
+export declare function runAdd(options: {
+    preview: AddPreview;
+    json: boolean;
+    cwd: string;
+}, deps: PreviewDeps): Promise<PreviewResult>;
+export declare function runList(options: {
+    json: boolean;
+    cwd: string;
+}, deps: PreviewDeps): Promise<PreviewResult>;
+/**
+ * Hand pending requests to whoever asks. An agent polls this, acts on each
+ * prompt, and clears the queue. Leglas runs no model of its own: the user's
+ * agent already knows their conventions and design system, which is context
+ * no external worker can have.
+ */
+export declare function runRequests(options: {
+    json: boolean;
+    clear: boolean;
+    cwd: string;
+}, deps: PreviewDeps): Promise<PreviewResult>;

package/dist/run.d.ts

@@ -0,0 +1,24 @@
+import type { RunOptions } from "./args.js";
+export type RunDeps = {
+    open(url: string): Promise<void>;
+    log(line: string): void;
+};
+export type RunResult = {
+    exitCode: number;
+    /** Where the interface lives, which is what gets opened and reported. */
+    url: string;
+    devServer: string;
+    previewCount: number;
+    stop(): Promise<void>;
+};
+/**
+ * Boot Leglas: resolve config, start the server, open the interface.
+ *
+ * Nothing here is fatal except being unable to bind a port. A missing config,
+ * an invalid config, or a dev server that is not running are all reported and
+ * survivable, because the user is mid-setup and needs to be told what to fix,
+ * not handed a stack trace.
+ */
+export declare function run(options: RunOptions & {
+    cwd: string;
+}, deps: RunDeps): Promise<RunResult>;