looply-cli 0.5.1 → 0.5.3

package/dist/bin.js

@@ -20,12 +20,14 @@ const evidence_facts_1 = require("./evidence-facts");
 const integration_deps_1 = require("./integration-deps");
 const lane_claims_1 = require("./lane-claims");
 const integration_runtime_2 = require("./integration-runtime");
-const agent_contained_1 = require("./agent-contained");
+const provider_discovery_1 = require("./provider-discovery");
+const provider_cmd_1 = require("./provider-cmd");
 const exec_domains_1 = require("./exec-domains");
 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");
@@ -48,6 +50,7 @@ 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 refresh_gates_1 = require("./refresh-gates");
 const core_1 = require("@looply/core");
 const sessions_cmd_1 = require("./sessions-cmd");
 const session_observe_runtime_1 = require("./session-observe-runtime");
@@ -77,67 +80,72 @@ 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 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
+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 provider [status]           is Claude Code installed, and is Looply signed in to it? (where it was found)
+  looply provider install [--yes]    install Claude Code globally with npm
+  looply provider login              sign Looply's own Claude Code profile in
+  looply init                        profile the repo and draft .looply/config.yaml
+  looply init --refresh-gates [--yes] re-draft only the gates of an existing config: shows the diff,
+                                     writes on y (or --yes); every other section is kept
+  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);
@@ -158,21 +166,42 @@ function nodeDoctorDeps() {
 /* istanbul ignore next — real fs, tty and cwd; the logic lives in setup.ts */
 async function init(argv) {
     const target = (0, path_1.resolve)('.looply/config.yaml');
-    // Never overwrite: by the time init is re-run the file is the user's, full of
-    // hand-tuned rails and gates a fresh draft would silently throw away.
-    if ((0, fs_1.existsSync)(target)) {
-        process.stderr.write(`init: ${target} already exists — move it aside first for a fresh draft\n`);
-        return 1;
-    }
-    // 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) => {
+    const readText = (p) => {
         try {
             return (0, fs_1.readFileSync)(p, 'utf8');
         }
         catch {
             return null;
         }
-    });
+    };
+    // The same reading `connect` and the supervisor take of a repository they set up (`repo-init.ts`).
+    const profileHere = () => (0, repo_init_1.profileOf)(process.cwd(), readText, repo_init_1.listDirsOf);
+    // Re-draft only the gates of an existing config; every other section is kept.
+    if (argv.includes('--refresh-gates')) {
+        const assumeYes = argv.includes('--yes') || argv.includes('-y');
+        const asker = !assumeYes && process.stdin.isTTY ? (0, setup_prompt_1.nodeAsker)() : null;
+        try {
+            return await (0, refresh_gates_1.runRefreshGates)({
+                configPath: target,
+                profile: profileHere(),
+                readText,
+                writeText: (p, text) => (0, fs_1.writeFileSync)(p, text),
+                write: (s) => process.stdout.write(s),
+                assumeYes,
+                confirm: asker ? async (q) => /^(y|yes)$/i.test((await asker.question(q)).trim()) : null,
+            });
+        }
+        finally {
+            asker?.close();
+        }
+    }
+    // Never overwrite: by the time init is re-run the file is the user's, full of
+    // hand-tuned rails and gates a fresh draft would silently throw away.
+    if ((0, fs_1.existsSync)(target)) {
+        process.stderr.write(`init: ${target} already exists — move it aside first for a fresh draft, or re-draft only its gates with --refresh-gates\n`);
+        return 1;
+    }
+    const profile = profileHere();
     // 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)([
@@ -183,8 +212,10 @@ async function init(argv) {
             : []),
         [
             'checks',
-            [profile.typecheck?.name, profile.testRunner?.name].filter(Boolean).join(', ') ||
-                (0, ui_1.dim)('none detected'),
+            (0, init_detect_1.profileGates)(profile)
+                .filter((g) => !g.disabled)
+                .map((g) => g.name)
+                .join(', ') || (0, ui_1.dim)('none detected'),
         ],
     ]), { title: 'what this project looks like' }) + '\n');
     // --yes for CI and for anyone who would rather edit the file than answer
@@ -345,12 +376,16 @@ async function doctor(argv) {
          * was reported as `refused`, advising a comparison of command-line flags.
          */
         const profile = (0, provider_state_1.providerProfileDir)();
-        const exe = resolved.spec.executable ?? (0, provider_state_1.providerExecutableFor)((0, agent_contained_1.claudePackageDir)());
+        const discovery = (0, provider_discovery_1.discoverProvider)(resolved.spec.executable);
+        const exe = discovery.found?.executable ?? null;
         if (exe === null) {
-            process.stdout.write('provider: no provider runtime was found — Claude Code is not installed beside node,\n');
-            process.stdout.write('          and agent.executable names none.\n');
+            process.stdout.write('provider: no provider runtime was found — Claude Code is not installed where Looply looks:\n');
+            for (const s of discovery.searched)
+                process.stdout.write(`            ${s}\n`);
+            process.stdout.write('          `looply provider install` installs it; agent.executable can name one elsewhere.\n');
             return 1;
         }
+        process.stdout.write(`provider: Claude Code at ${exe} (from ${provider_discovery_1.SOURCE_WORDS[discovery.found.source]})\n`);
         const sessionDir = (0, model_transport_1.providerSessionDir)(process.cwd(), 'implementer');
         const ready = (0, provider_state_1.checkProviderAuth)(exe, { ...(0, exec_domains_1.buildProviderEnv)(sessionDir), CLAUDE_CONFIG_DIR: profile });
         if (!ready.ok) {
@@ -894,6 +929,7 @@ function nodeSessionsDeps() {
                                 env: (0, trusted_git_1.trustedGitEnv)(process.env, workspace),
                                 encoding: 'utf8',
                                 stdio: ['ignore', 'pipe', 'ignore'],
+                                windowsHide: true,
                             }).trim();
                         }
                         catch {
@@ -1505,7 +1541,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) {
@@ -1565,9 +1601,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}`)}
 `);
     }
     /**
@@ -1609,16 +1645,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;
         }
@@ -1636,7 +1672,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);
@@ -1774,7 +1810,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`)}
 `);
         }
         /**
@@ -1811,9 +1847,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) {
@@ -1951,12 +1987,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');
@@ -2483,7 +2519,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
@@ -2668,6 +2704,8 @@ async function main(argv) {
             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 'provider':
+            return (0, provider_cmd_1.providerCommand)(rest, (0, provider_cmd_1.nodeProviderDeps)());
         case 'scan':
             return scan(rest);
         case 'verify':
@@ -2705,7 +2743,7 @@ async function main(argv) {
         case 'version':
         case '--version':
         case '-v':
-            process.stdout.write('0.1.0\n');
+            process.stdout.write(`${JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '..', 'package.json'), 'utf8')).version}\n`);
             return 0;
         case undefined:
             return welcome();