looply-cli 0.3.0 → 0.5.0

package/dist/.src-hash

@@ -1 +1 @@
-0718ecc55a9ad89af6ef6bfb9f39e9139d823f2be48bcd1675cb79cd8be97d7a
+5d1be87f831ce39b9f1f2f1c05ba77ec38bea063b77a89727a0c1c240c8b7bdf

package/dist/bin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AA2wFA,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAmE1D"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AA6wFA,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAqE1D"}

package/dist/bin.js

@@ -26,7 +26,6 @@ const model_transport_1 = require("./model-transport");
 const provider_state_1 = require("./provider-state");
 const providers_1 = require("./providers");
 const provider_preflight_1 = require("./provider-preflight");
-const init_detect_1 = require("./init-detect");
 const report_cmd_1 = require("./report-cmd");
 const tool_call_record_1 = require("./tool-call-record");
 const token_window_1 = require("./token-window");
@@ -46,6 +45,9 @@ const ledger_store_1 = require("./ledger-store");
 const git_driver_1 = require("./git-driver");
 const repos_cmd_1 = require("./repos-cmd");
 const serve_cmd_1 = require("./serve-cmd");
+const connect_1 = require("./connect");
+const connect_node_1 = require("./connect-node");
+const repo_init_1 = require("./repo-init");
 const core_1 = require("@looply/core");
 const sessions_cmd_1 = require("./sessions-cmd");
 const session_observe_runtime_1 = require("./session-observe-runtime");
@@ -75,64 +77,67 @@ const integration_1 = require("./integration");
  * "not implemented yet" is worse than one that does not exist, because it looks
  * like a broken feature rather than an unbuilt one.
  */
-const USAGE = `looply — an autonomous build loop you drive from your phone
-
-usage:
-  looply pair [--server <url>]        pair this machine with your phone
-  looply daemon [--once] [--yes]      stay connected: presence, and ship the ledger
-  looply serve add [path]            serve this repository (or <path>) from one machine-wide supervisor
-  looply serve remove <path>         stop serving a repository
-  looply serve list                  the served repositories, and whether each still has .looply/config.yaml
-  looply serve                       run the supervisor: one daemon per served repository, restarted if it stops
-  looply serve install | uninstall   start the supervisor at login (Windows); prints a service template elsewhere
-  looply init                        profile the repo and draft .looply/config.yaml
-  looply doctor [--config <path>] [--provider]
-                                     validate the config and run one full gate pass; --provider also asks the model to answer once
-  looply scan [--lens a,b] [--dry-run] read the code through several lenses and fill the queue
-  looply verify [--max N]            check unverified items against the code, so a run can pick them
-  looply queue [--all]               everything waiting, and why
-  looply integrate --init <ref>      create looply/integration from a base you name
-  looply integrate --branch <name> [--goal <id>]
-                                     offer one finished branch to the integration queue:
-                                     fast-forward or nothing, checked at the commit that
-                                     would actually be published (needs run.integration)
-  looply runs [--reap]               what this project is running; --reap retires proven-dead leftovers
-  looply runs --release <runId|slot-N|claim-lock>
-                                     clear a leftover a recycled pid makes look alive
-  looply source add <file> [--name <n>]
-                                     hand a Markdown (.md) or plain-text (.txt) document to
-                                     this project, verbatim, from the machine that holds it
-  looply source list                 what this project has been given
-  looply source show <id>            one source: its statements, what each IS, where each came from,
-                                     and where each requirement stands against this repository
-  looply source reconcile <id>       measure where each requirement stands against this repository
-                                     (HEAD's tree, by name — a place to look, never "implemented"), and record it
-  looply source coverage <id>        which requirements no goal serves, which are served, and which a person
-                                     evidenced — a finished queue is not coverage
-  looply stop                        finish the round in flight, then stop
-  looply pause | looply resume       hold between rounds, and let it go again
-  looply run [--hours N] [--dry-run] [--in <workspace> | --new-workspace]
-                                     start a run: pick, implement, gate, prove, keep or discard
-                                     --in runs it in another checkout of this repository, so two
-                                     runs can work at once without sharing a tree
-                                     --try-once-more spends a stopped goal's ONE retry (never
-                                     turns the brake off; the next failure stops it again)
-  looply status                     one-screen snapshot from .looply/state/status.json
-  looply report                     run report from the local ledger, alerts first
-  looply goal <id>                  one goal from this machine's records: the grant and the lane's answer,
-                                     compiles, proposals, the lane's attempts, each run's rounds — read-only
-  looply goals                      every mirrored goal, one line each, with its grant's standing
-  looply repos [--accept] [--published <repo>]
-                                    the other repositories this programme spans: where each one is,
-                                    and whether the revisions somebody accepted together still hold
-  looply evidence                   what this project has accumulated, and what the retention
-                                    policy would do with it. It deletes nothing.
-  looply sessions [--offer <file>] [--ack <id>]
-                                    sessions this machine did not start, asking to be managed;
-                                    observe-only — authorizing control is the server's to give
-  looply version
-
-not built yet: item
+const USAGE = `looply — an autonomous build loop you drive from your phone
+
+usage:
+  looply connect [--root <dir>]... [--yes] [--no-start]
+                                     once per machine: pair it (if needed), then set up and serve every git
+                                     repository under each root; new ones there, and clones you ask for, follow
+  looply pair [--server <url>]        pair this machine with your phone
+  looply daemon [--once] [--yes]      stay connected: presence, and ship the ledger
+  looply serve add [path]            serve this repository (or <path>) from one machine-wide supervisor
+  looply serve remove <path>         stop serving a repository
+  looply serve list                  the served repositories, and whether each still has .looply/config.yaml
+  looply serve                       run the supervisor: one daemon per served repository, restarted if it stops
+  looply serve install | uninstall   start the supervisor at login (Windows); prints a service template elsewhere
+  looply init                        profile the repo and draft .looply/config.yaml
+  looply doctor [--config <path>] [--provider]
+                                     validate the config and run one full gate pass; --provider also asks the model to answer once
+  looply scan [--lens a,b] [--dry-run] read the code through several lenses and fill the queue
+  looply verify [--max N]            check unverified items against the code, so a run can pick them
+  looply queue [--all]               everything waiting, and why
+  looply integrate --init <ref>      create looply/integration from a base you name
+  looply integrate --branch <name> [--goal <id>]
+                                     offer one finished branch to the integration queue:
+                                     fast-forward or nothing, checked at the commit that
+                                     would actually be published (needs run.integration)
+  looply runs [--reap]               what this project is running; --reap retires proven-dead leftovers
+  looply runs --release <runId|slot-N|claim-lock>
+                                     clear a leftover a recycled pid makes look alive
+  looply source add <file> [--name <n>]
+                                     hand a Markdown (.md) or plain-text (.txt) document to
+                                     this project, verbatim, from the machine that holds it
+  looply source list                 what this project has been given
+  looply source show <id>            one source: its statements, what each IS, where each came from,
+                                     and where each requirement stands against this repository
+  looply source reconcile <id>       measure where each requirement stands against this repository
+                                     (HEAD's tree, by name — a place to look, never "implemented"), and record it
+  looply source coverage <id>        which requirements no goal serves, which are served, and which a person
+                                     evidenced — a finished queue is not coverage
+  looply stop                        finish the round in flight, then stop
+  looply pause | looply resume       hold between rounds, and let it go again
+  looply run [--hours N] [--dry-run] [--in <workspace> | --new-workspace]
+                                     start a run: pick, implement, gate, prove, keep or discard
+                                     --in runs it in another checkout of this repository, so two
+                                     runs can work at once without sharing a tree
+                                     --try-once-more spends a stopped goal's ONE retry (never
+                                     turns the brake off; the next failure stops it again)
+  looply status                     one-screen snapshot from .looply/state/status.json
+  looply report                     run report from the local ledger, alerts first
+  looply goal <id>                  one goal from this machine's records: the grant and the lane's answer,
+                                     compiles, proposals, the lane's attempts, each run's rounds — read-only
+  looply goals                      every mirrored goal, one line each, with its grant's standing
+  looply repos [--accept] [--published <repo>]
+                                    the other repositories this programme spans: where each one is,
+                                    and whether the revisions somebody accepted together still hold
+  looply evidence                   what this project has accumulated, and what the retention
+                                    policy would do with it. It deletes nothing.
+  looply sessions [--offer <file>] [--ack <id>]
+                                    sessions this machine did not start, asking to be managed;
+                                    observe-only — authorizing control is the server's to give
+  looply version
+
+not built yet: item
 `;
 function loadConfig(path) {
     const full = (0, path_1.resolve)(path);
@@ -159,16 +164,15 @@ async function init(argv) {
         process.stderr.write(`init: ${target} already exists — move it aside first for a fresh draft\n`);
         return 1;
     }
-    const profile = (0, init_detect_1.detectRepo)({
-        readFile: (p) => {
-            try {
-                return (0, fs_1.readFileSync)((0, path_1.resolve)(p), 'utf8');
-            }
-            catch {
-                return null;
-            }
-        },
-    }, (0, path_1.basename)(process.cwd()));
+    // The same reading `connect` and the supervisor take of a repository they set up (`repo-init.ts`).
+    const profile = (0, repo_init_1.profileOf)(process.cwd(), (p) => {
+        try {
+            return (0, fs_1.readFileSync)(p, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    });
     // What detection found, before anything is asked — so the questions arrive
     // with context rather than out of nowhere.
     process.stdout.write((0, ui_1.box)((0, ui_1.fields)([
@@ -1501,7 +1505,7 @@ async function runs(argv) {
                 'claim lock',
                 `held by ${who}  ${(0, ui_1.dim)(lock.liveness === 'dead' ? 'the next start will break it' : '`looply runs --release claim-lock` clears it')}`,
             ],
-        ]), { title: 'starting' })}
+        ]), { title: 'starting' })}
 `);
     }
     if (slots.length > 0) {
@@ -1561,9 +1565,9 @@ async function runs(argv) {
                     ];
             }),
         ];
-        process.stdout.write(`${(0, ui_1.box)((0, ui_1.fields)(rows), { title: 'workspaces' })}
+        process.stdout.write(`${(0, ui_1.box)((0, ui_1.fields)(rows), { title: 'workspaces' })}
 `);
-        process.stdout.write(`  ${(0, ui_1.dim)(`…  =  ${wsRootShown}`)}
+        process.stdout.write(`  ${(0, ui_1.dim)(`…  =  ${wsRootShown}`)}
 `);
     }
     /**
@@ -1605,16 +1609,16 @@ async function runs(argv) {
             if (lock !== null && lock.liveness !== 'dead') {
                 const how = lock.liveness === 'alive' ? 'answers' : 'cannot be judged';
                 process.stdout.write(`  ${(0, ui_1.warn)('note')} — pid ${lock.pid ?? '?'} ${how}. If that is a start still deciding, ` +
-                    `clearing this lets another one decide alongside it.
+                    `clearing this lets another one decide alongside it.
 `);
             }
             const cleared = registry.forgetClaimLock();
             process.stdout.write(cleared
-                ? `  claim-lock: cleared — the next start decides for itself
-
+                ? `  claim-lock: cleared — the next start decides for itself
+
 `
-                : `  claim-lock: nothing to clear
-
+                : `  claim-lock: nothing to clear
+
 `);
             return cleared ? 0 : 2;
         }
@@ -1632,7 +1636,7 @@ async function runs(argv) {
             const holder = slots.find((sl) => sl.slot === n)?.record ?? null;
             if (holder !== null && (0, workspace_1.nodeProbe)(holder.pid) !== 'dead') {
                 process.stdout.write(`  ${(0, ui_1.warn)('note')} — slot-${n} names ${holder.runId}, pid ${holder.pid}, which answers. ` +
-                    `Clearing it lets another execution start alongside it.
+                    `Clearing it lets another execution start alongside it.
 `);
             }
             const cleared = registry.forgetSlot(n);
@@ -1770,7 +1774,7 @@ async function runs(argv) {
                 : `  ${(0, ui_1.dim)(`${orphans.length} orphaned, none in a checkout looply made — looply runs --release <runId>`)}\n`);
         }
         if (abandoned.length > 0) {
-            process.stdout.write(`  ${(0, ui_1.dim)(`${abandoned.length} checkout(s) nothing accounts for — \`looply runs --reap\` retires those it can`)}
+            process.stdout.write(`  ${(0, ui_1.dim)(`${abandoned.length} checkout(s) nothing accounts for — \`looply runs --reap\` retires those it can`)}
 `);
         }
         /**
@@ -1807,9 +1811,9 @@ async function runs(argv) {
     for (const w of abandoned) {
         const out = await (0, workspace_1.reapAbandoned)(git, process.cwd(), w, undefined, undefined, undefined, carried);
         process.stdout.write(out.reaped
-            ? `  ${(0, path_1.basename)(w)}: retired — no execution accounted for it
+            ? `  ${(0, path_1.basename)(w)}: retired — no execution accounted for it
 `
-            : `  ${(0, path_1.basename)(w)}: ${(0, ui_1.warn)('kept')} — ${out.because ?? 'unknown'}
+            : `  ${(0, path_1.basename)(w)}: ${(0, ui_1.warn)('kept')} — ${out.because ?? 'unknown'}
 `);
     }
     for (const e of entries) {
@@ -1947,12 +1951,12 @@ async function stop(argv, kind = 'stop') {
          * the one place a person looks to check the brake reached everything.
          */
         const told = kind === 'resume' ? 'were told to carry on' : `were told to ${kind}`;
-        process.stdout.write(`
-  ${(0, ui_1.dim)(`${addressed.length} of ${running.length} running executions ${told}.`)}
+        process.stdout.write(`
+  ${(0, ui_1.dim)(`${addressed.length} of ${running.length} running executions ${told}.`)}
 `);
     }
     if (unreachable.length > 0) {
-        process.stdout.write(`  ${(0, ui_1.warn)('could not reach')} ${unreachable.join(', ')} — their state directories could not be written
+        process.stdout.write(`  ${(0, ui_1.warn)('could not reach')} ${unreachable.join(', ')} — their state directories could not be written
 `);
     }
     process.stdout.write('\n  ' + (0, queue_view_1.stopMessage)(live, kind) + '\n');
@@ -2479,7 +2483,7 @@ async function run(argv) {
         // the daemon that spawned this cannot, because it spawns with
         // `stdio: 'ignore'` on a detached child, so the words go nowhere. Both are
         // told, by the channel each can actually hear.
-        process.stderr.write(`${e.message}
+        process.stderr.write(`${e.message}
 `);
         // Only when something asked. A hand-typed `looply run` has no request to
         // answer, and writing a mark nobody will ever look up would make this file
@@ -2662,6 +2666,8 @@ async function main(argv) {
             return daemon(rest);
         case 'serve':
             return (0, serve_cmd_1.serveCommand)(rest, (0, serve_cmd_1.nodeServeDeps)());
+        case 'connect':
+            return (0, connect_1.connectCommand)(rest, (0, connect_node_1.nodeConnectDeps)(DEFAULT_SERVER));
         case 'scan':
             return scan(rest);
         case 'verify':