@ashulab/carrier 0.0.0-stage → 0.1.0

package/dist/terminal/wizard/wizard.js

@@ -0,0 +1,172 @@
+import { join, resolve } from 'node:path';
+import { carrierHome } from '../../config/default-path.js';
+import { defaults, loadConfig } from '../../config/load.js';
+import { installFix } from '../../doctor/fixes.js';
+import { localKinds } from '../../harnesses/local.js';
+import { harnessNames } from '../../harnesses/names.js';
+import { Cancelled } from '../prompts/types.js';
+import { buildConfig, identityText, parseIdentity } from './build-config.js';
+import { realDeps } from './deps.js';
+import { priorFrom } from './prior.js';
+import { askIdentities } from './questions/identities.js';
+import { askIdentity } from './questions/identity.js';
+import { askFailover, askProviders, askRoleProvider, declareFlaggedProvider } from './questions/options.js';
+import { askModel } from './questions/agent.js';
+import { askPersona } from './questions/persona.js';
+import { askOut } from './questions/out.js';
+import { askRepos } from './questions/repos.js';
+import { summary, tilde } from './summary.js';
+const ghIdentity = { kind: 'gh' };
+/** The setup flow: look at the machine, ask what is missing, recap, save, check, offer to start. */
+export async function runInit(flags, ui, deps = realDeps, folder = carrierHome()) {
+    ui.intro('Carrier setup');
+    const interactive = ui.interactive && !flags.yes; // --yes never asks, whatever the terminal
+    const forge = { agents: [] };
+    const readForge = () => {
+        try {
+            forge.agents = deps.forgeAgents();
+        }
+        catch (error) {
+            ui.warn(`Could not read the Agent Forge registry: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const harnesses = harnessNames.filter((p) => deps.which(p));
+    const login = deps.ghLogin();
+    // Local model servers are optional: a server that is not running is shown as such, not as a failure.
+    const locals = {};
+    for (const kind of localKinds)
+        locals[kind] = await deps.localModels(kind).catch(() => undefined);
+    // Nothing is shown when the machine is fine. What cannot work at all stops here, with how to fix it.
+    const lacking = [
+        ...['git', 'gh'].filter((tool) => !deps.which(tool)).map((tool) => `${tool}: ${installFix[tool]}`),
+        ...(harnesses.length === 0 ? ['an agent CLI, any of these:', ...harnessNames.map((h) => `  ${h}: ${installFix[h]}`)] : []),
+    ];
+    if (lacking.length > 0)
+        throw new Error(`Carrier needs these before it can run:\n${lacking.map((line) => `  ${line}`).join('\n')}`);
+    if (login === undefined)
+        ui.warn('gh is not logged in (run: gh auth login): your repos cannot be listed, and a "my own gh login" identity will not work.');
+    // A config that is already there: edit it (its answers become the starting points), start over, or leave it.
+    const fallback = join(folder, 'config.json');
+    let out = flags.out === undefined ? undefined : resolve(flags.out);
+    let settled = false; // the question below settled where the config goes, and that it may be replaced
+    let prior;
+    if (flags.out === undefined && interactive && deps.exists(fallback)) {
+        const choice = await ui.select({
+            message: `A config already exists at ${tilde(fallback)}`,
+            options: [
+                { value: 'edit', label: 'Edit it', hint: 'its answers are the starting points' },
+                { value: 'fresh', label: 'Start over', hint: 'replaces it' },
+                { value: 'elsewhere', label: 'Save a new one in another file' },
+                { value: 'cancel', label: 'Leave it as it is' },
+            ],
+            initialValue: 'edit',
+        });
+        if (choice === 'cancel')
+            throw new Cancelled();
+        if (choice === 'edit' || choice === 'fresh') {
+            out = fallback;
+            settled = true;
+        }
+        if (choice === 'edit') {
+            try {
+                prior = priorFrom(deps.readConfig(fallback));
+            }
+            catch {
+                // unreadable: handled as no prior below
+            }
+            if (prior === undefined)
+                ui.warn(`${tilde(fallback)} is not a valid config, so there is nothing to start from.`);
+        }
+    }
+    const repos = flags.repo ?? (await askRepos(ui, deps, prior?.repos));
+    // 1. AI Providers: accounts and connections (pure setup, no models)
+    let providers = { ...prior?.providers };
+    const flagged = (roleKey, roleName) => {
+        const flag = flags[roleKey];
+        if (flag === undefined)
+            return undefined;
+        const declared = declareFlaggedProvider(providers, roleName.replace(/\s+/g, '-'), flag, flags[`${roleKey}Provider`]);
+        providers = declared.providers;
+        return { provider: declared.providerName, model: declared.model };
+    };
+    const [flaggedAuthor, flaggedReviewer, flaggedLeadReviewer] = [flagged('author', 'author'), flagged('reviewer', 'reviewer'), flagged('leadReviewer', 'lead reviewer')];
+    const unattended = flaggedAuthor !== undefined && flaggedReviewer !== undefined;
+    if (!unattended)
+        providers = await askProviders(ui, providers, harnesses, locals, deps);
+    // 2. GitHub identities: shared vs separate, resolved together
+    const identities = await askIdentities(ui, flags, login, interactive, prior?.identities);
+    const shared = identities === 'shared';
+    if (!shared)
+        readForge();
+    const authorIdentity = shared ? ghIdentity : flags.authorProfile ? parseIdentity(flags.authorProfile) : await askIdentity(ui, 'author', forge, readForge, login, [], deps, interactive, prior?.author.identity);
+    const reviewerIdentity = shared ? ghIdentity : flags.reviewerProfile ? parseIdentity(flags.reviewerProfile) : await askIdentity(ui, 'reviewer', forge, readForge, login, [authorIdentity], deps, interactive, prior?.reviewer.identity);
+    if (!shared && identityText(authorIdentity) === identityText(reviewerIdentity))
+        throw new Error('Author and reviewer identities must differ');
+    // 3. Agents: Author and Reviewer (provider, model, persona)
+    if (!(flags.authorProfile && flags.author))
+        ui.note('Implements the epic: runs ship, then answers the reviewer.\nOptionally it gets a persona at the end: a name and how it behaves.', 'Author');
+    const authorProvider = flaggedAuthor?.provider ?? (await askRoleProvider(ui, 'author', providers, prior?.author.provider));
+    const authorModel = flaggedAuthor?.model ?? (await askModel(ui, providers[authorProvider].harness, providers[authorProvider].provider, locals, deps, 'author', prior?.author.model));
+    const authorPersona = await askPersona(ui, 'author', { name: flags.authorPersonaName, prompt: flags.authorPersonaPrompt }, interactive, prior?.author.persona);
+    const author = { identity: authorIdentity, provider: authorProvider, model: authorModel, ...(authorPersona && { persona: authorPersona }) };
+    if (!(flags.reviewerProfile && flags.reviewer))
+        ui.note('Reviews the final PR.\nOptionally it gets a persona at the end: a name and how it behaves.', 'Reviewer');
+    const reviewerProvider = flaggedReviewer?.provider ?? (await askRoleProvider(ui, 'reviewer', providers, prior?.reviewer.provider, authorProvider));
+    const reviewerModel = flaggedReviewer?.model ?? (await askModel(ui, providers[reviewerProvider].harness, providers[reviewerProvider].provider, locals, deps, 'reviewer', prior?.reviewer.model));
+    const reviewerPersona = await askPersona(ui, 'reviewer', { name: flags.reviewerPersonaName, prompt: flags.reviewerPersonaPrompt }, interactive, prior?.reviewer.persona);
+    const reviewer = { identity: reviewerIdentity, provider: reviewerProvider, model: reviewerModel, ...(reviewerPersona && { persona: reviewerPersona }) };
+    // 4. Optional Lead Reviewer (Tech Lead role setup)
+    let leadReviewer;
+    const wantLead = flags.leadReviewer !== undefined
+        ? true
+        : interactive
+            ? await (async () => {
+                ui.note('An optional technical lead role (configuration setup).\nIt configures an evaluation role for architecture and production readiness.', 'Lead Reviewer');
+                return ui.confirm('Add a Lead Reviewer to the workflow?');
+            })()
+            : prior?.leadReviewer !== undefined;
+    if (wantLead) {
+        const leadIdentity = shared
+            ? ghIdentity
+            : flags.leadReviewerProfile
+                ? parseIdentity(flags.leadReviewerProfile)
+                : await askIdentity(ui, 'lead reviewer', forge, readForge, login, [authorIdentity], deps, interactive, prior?.leadReviewer?.identity ?? reviewerIdentity);
+        if (!shared && identityText(authorIdentity) === identityText(leadIdentity)) {
+            throw new Error('Author and lead reviewer identities must differ');
+        }
+        const leadProvider = flaggedLeadReviewer?.provider ?? (await askRoleProvider(ui, 'lead reviewer', providers, prior?.leadReviewer?.provider, reviewerProvider));
+        const leadModel = flaggedLeadReviewer?.model ?? (await askModel(ui, providers[leadProvider].harness, providers[leadProvider].provider, locals, deps, 'lead reviewer', prior?.leadReviewer?.model));
+        const leadPersona = await askPersona(ui, 'lead reviewer', { name: flags.leadReviewerPersonaName, prompt: flags.leadReviewerPersonaPrompt }, interactive, prior?.leadReviewer?.persona);
+        leadReviewer = { identity: leadIdentity, provider: leadProvider, model: leadModel, ...(leadPersona && { persona: leadPersona }) };
+    }
+    const failover = prior?.failover ?? (unattended || Object.keys(providers).length < 2 ? undefined : await askFailover(ui, providers));
+    const user = buildConfig({ repos, author, reviewer, leadReviewer, providers, failover, identities });
+    const loaded = loadConfig(defaults, user);
+    if (!loaded.ok)
+        throw new Error(`the answers do not make a valid config:\n${loaded.errors.map((e) => `  ${e.path}: ${e.message}`).join('\n')}`);
+    out ??= resolve(await askOut(ui, fallback));
+    if (!settled && deps.exists(out) && !flags.yes && !(await ui.confirm(`${out} exists. Overwrite it?`)))
+        throw new Error(`${out} already exists`);
+    if (interactive) {
+        ui.note(summary(repos, author, reviewer, providers, failover, out, identities, leadReviewer), 'This is what will be saved');
+        if (!(await ui.confirm('Save it?')))
+            throw new Cancelled();
+    }
+    deps.write(out, `${JSON.stringify(user, null, 2)}\n`);
+    ui.note(tilde(out), 'Config written');
+    const checks = await deps.doctor(loaded.config, folder, {}, ui.check, ui.checkStart);
+    const use = out === fallback ? '' : ` --config ${out}`; // the default location needs no flag
+    const failed = checks.filter((c) => c.status === 'fail').length;
+    ui.checksEnd(checks.length, failed);
+    if (failed > 0) {
+        ui.outro(`${failed} check${failed === 1 ? '' : 's'} failed. Fix them and run: carrier doctor${use}`);
+        return { path: out, checks, config: loaded.config, start: false };
+    }
+    const ready = await deps.readyEpics(loaded.config, folder);
+    const waiting = Object.entries(ready).map(([repo, count]) => `${repo}: ${count === undefined ? 'could not read' : `${count} epic${count === 1 ? '' : 's'} marked ready`}`);
+    ui.note(waiting.join('\n'), 'Waiting for Carrier');
+    const start = interactive && (await ui.confirm('Start Carrier now? (Ctrl+C stops it)'));
+    if (!start)
+        ui.outro(`Ready. Start it with: carrier${use}\nThen mark an epic of ${repos[0]} as solve:epic:ready.`); // otherwise the caller carries on in the same frame
+    return { path: out, checks, config: loaded.config, start };
+}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@ashulab/carrier",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Autonomous epic orchestrator: ships and reviews Solve epics with AI agents on your machine.",
+  "author": "Diego Ghersi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AshuLab/carrier.git"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "carrier": "./dist/terminal/cli/main.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.311",
+    "@ashulab/universal-logger": "^0.1.1",
+    "@clack/prompts": "^1.8.1",
+    "better-sqlite3": "^13.0.3",
+    "drizzle-orm": "^0.45.4",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^9.6.0",
+    "@types/node": "^26.6.5",
+    "drizzle-kit": "^0.31.11",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp -r src/storage/migrations dist/storage/migrations && cp -r src/chat/migrations dist/chat/migrations && chmod +x dist/terminal/cli/main.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.ts --passWithNoTests",
+    "db:generate": "drizzle-kit generate && drizzle-kit generate --config drizzle.chat.config.ts",
+    "replay:events": "node src/harnesses/replay-events.ts"
+  }
 }