leglas 0.1.1 → 0.3.0

package/dist/resolve-title.d.ts

@@ -0,0 +1,19 @@
+import { type Renames } from "@leglas/server";
+export type Resolved = {
+    ok: true;
+    title: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Resolve a name a command was given, and say something useful when it cannot.
+ *
+ * The message matters more than usual here. A direction renamed in the rail is
+ * only renamed on this machine, so the name a user says is often not the name
+ * the config spells; that gap is covered by resolving through the rename map.
+ * What is left is a name nothing answers to, where the old message ("run
+ * leglas list") sent an agent to a listing that would not contain the name
+ * either, and the second miss reads as "the direction is gone".
+ */
+export declare function resolveOrExplain(input: string, titles: readonly string[], renames: Renames): Resolved;

package/dist/run-explore.d.ts

@@ -2,16 +2,17 @@ export type ExploreDeps = {
     log(line: string): void;
 };
 /**
- * Hand an agent several genuinely different angles at once.
+ * Brief an agent's exploration.
  *
- * 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.
+ * Leglas runs no model, and it hands out no taste either: the agent has the
+ * product, the surface and the design system in context, which is where taste
+ * comes from. This prints the part the agent cannot know: how a set registers
+ * and displays here, what the set is for, and how sets fail.
  */
 export declare function runExplore(options: {
     surface: string;
     count: number;
+    basedOn: string | null;
     json: boolean;
 }, deps: ExploreDeps): {
     exitCode: number;

package/dist/run-show.d.ts

@@ -0,0 +1,18 @@
+export type ShowDeps = {
+    log(line: string): void;
+    error(line: string): void;
+};
+/**
+ * Answer for one direction, for whoever was handed its reference block.
+ *
+ * Addressing is by config title, which is what every other command takes and
+ * what the block quotes, so a renamed direction is still reachable by the name
+ * the project knows it by.
+ */
+export declare function runShow(options: {
+    title: string;
+    json: boolean;
+    cwd: string;
+}, deps: ShowDeps): Promise<{
+    exitCode: number;
+}>;

package/dist/run-watch.d.ts

@@ -0,0 +1,23 @@
+export type WatchDeps = {
+    log(line: string): void;
+    error(line: string): void;
+};
+/**
+ * Hand change requests to the user's own agent as they arrive.
+ *
+ * This is the whole live loop: the interface writes a request, watch picks it
+ * up, the user's agent does the work with the user's keys and the user's model.
+ * Leglas still runs no model of its own. What it adds is locality, so asking
+ * for a change no longer means leaving the comparison for a terminal.
+ *
+ * Resolves when the watcher stops, which is what a signal does, so the caller
+ * stays the same shape as every other command.
+ */
+export declare function runWatch(options: {
+    run: string | undefined;
+    port: number | undefined;
+    cwd: string;
+    signal?: AbortSignal;
+}, deps: WatchDeps): Promise<{
+    exitCode: number;
+}>;