@azad-73/cli 0.1.0

package/dist/azad.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+
+// src/azad.ts
+import { spawn } from "node:child_process";
+import fs2 from "node:fs";
+import path4 from "node:path";
+import readline from "node:readline";
+
+// ../engine/src/index.ts
+import {
+  SessionManager as SessionManager2,
+  createAgentSession
+} from "@earendil-works/pi-coding-agent";
+
+// ../shared/src/index.ts
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var AZAD_DIR = process.env.AZAD_DIR ?? path.join(os.homedir(), ".azad");
+function resolveCoreDataDir(sub, fromUrl) {
+  const here = path.dirname(fileURLToPath(fromUrl));
+  const candidates = [path.join(here, "core", sub)];
+  try {
+    const req = createRequire(fromUrl);
+    candidates.push(path.join(path.dirname(req.resolve("@azad-73/core/package.json")), sub));
+  } catch {
+  }
+  return candidates.find((c) => existsSync(c)) ?? candidates[0];
+}
+function defaultWorkspace(rootDir = process.cwd()) {
+  return { id: "default", rootDir, agentDir: AZAD_DIR, displayName: "Azad73" };
+}
+
+// ../engine/src/auth.ts
+import path2 from "node:path";
+import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+function createAuth(workspace) {
+  const authStorage = AuthStorage.create(path2.join(workspace.agentDir, "auth.json"));
+  const modelRegistry = ModelRegistry.create(authStorage, path2.join(workspace.agentDir, "models.json"));
+  return { authStorage, modelRegistry };
+}
+
+// ../engine/src/agents.ts
+import fs from "node:fs";
+import path3 from "node:path";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+function discoverAgents(dirs) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const entry of fs.readdirSync(dir)) {
+      if (!entry.endsWith(".md")) continue;
+      const filePath = path3.join(dir, entry);
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf8");
+      } catch {
+        continue;
+      }
+      const { frontmatter, body } = parseFrontmatter(content);
+      const name = frontmatter.name?.trim();
+      const description = frontmatter.description?.trim();
+      if (!name || !description) continue;
+      const tools = (frontmatter.tools ?? "").split(",").map((t) => t.trim()).filter(Boolean);
+      byName.set(name, {
+        name,
+        description,
+        tools,
+        preferredModel: frontmatter["x-preferred-model"],
+        source: frontmatter.source ?? "workspace",
+        filePath,
+        systemPrompt: body.trim()
+      });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// ../engine/src/tui.ts
+import { InteractiveMode } from "@earendil-works/pi-coding-agent";
+
+// ../engine/src/runtime.ts
+import {
+  SessionManager,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices
+} from "@earendil-works/pi-coding-agent";
+
+// ../engine/src/branding.ts
+import { VERSION } from "@earendil-works/pi-coding-agent";
+function coreThemesDir() {
+  return resolveCoreDataDir("themes", import.meta.url);
+}
+function brandBanner(theme) {
+  const accent = (s) => theme.fg("accent", s);
+  const muted = (s) => theme.fg("muted", s);
+  const dim = (s) => theme.fg("dim", s);
+  return [
+    "",
+    `  ${accent("\u2588\u258C")} ${accent("Azad73")}`,
+    `  ${muted("agentic AI \u2014 free to run, yours to own")} ${dim(`\xB7 pi ${VERSION}`)}`,
+    ""
+  ];
+}
+var brandingExtension = (pi) => {
+  pi.on("session_start", async (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    ctx.ui.setTitle("Azad73");
+    ctx.ui.setHeader((_tui, theme) => ({
+      render(_width) {
+        return brandBanner(theme);
+      },
+      invalidate() {
+      }
+    }));
+  });
+};
+
+// ../engine/src/runtime.ts
+async function buildRuntime(workspace = defaultWorkspace(), sessionManager = SessionManager.create(workspace.rootDir)) {
+  const { authStorage, modelRegistry } = createAuth(workspace);
+  const createRuntime = async ({ cwd, sessionManager: sm, sessionStartEvent }) => {
+    const services = await createAgentSessionServices({
+      cwd,
+      agentDir: workspace.agentDir,
+      authStorage,
+      modelRegistry,
+      resourceLoaderOptions: {
+        extensionFactories: [brandingExtension],
+        additionalThemePaths: [coreThemesDir()]
+      }
+    });
+    return {
+      ...await createAgentSessionFromServices({ services, sessionManager: sm, sessionStartEvent }),
+      services,
+      diagnostics: services.diagnostics
+    };
+  };
+  return createAgentSessionRuntime(createRuntime, {
+    cwd: workspace.rootDir,
+    agentDir: workspace.agentDir,
+    sessionManager
+  });
+}
+
+// ../engine/src/tui.ts
+async function runInteractive(workspace = defaultWorkspace()) {
+  const runtime = await buildRuntime(workspace);
+  const mode = new InteractiveMode(runtime);
+  await mode.run();
+}
+
+// src/azad.ts
+import { VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
+var PROVIDER = "anthropic";
+function coreAgentsDir() {
+  return resolveCoreDataDir("agents", import.meta.url);
+}
+function agentDirs() {
+  const ws = defaultWorkspace();
+  return [coreAgentsDir(), workspaceAgentsDir(), path4.join(ws.rootDir, ".azad", "agents")];
+}
+function workspaceAgentsDir() {
+  return path4.join(defaultWorkspace().agentDir, "agents");
+}
+var AGENT_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function newAgent(name) {
+  if (!name) {
+    console.error("usage: azad agents new <name>");
+    process.exit(1);
+  }
+  if (!AGENT_NAME_RE.test(name)) {
+    console.error("invalid name: use lowercase letters, digits, and single hyphens (e.g. my-agent)");
+    process.exit(1);
+  }
+  const dir = workspaceAgentsDir();
+  const file = path4.join(dir, `${name}.md`);
+  if (fs2.existsSync(file)) {
+    console.error(`agent already exists: ${file}`);
+    process.exit(1);
+  }
+  fs2.mkdirSync(dir, { recursive: true });
+  const template = [
+    "---",
+    `name: ${name}`,
+    "description: TODO \u2014 what this agent does and when to use it. Be specific.",
+    "tools: read, grep, find, ls",
+    "---",
+    "",
+    `You are ${name}.`,
+    "",
+    "TODO: write the system prompt.",
+    ""
+  ].join("\n");
+  fs2.writeFileSync(file, template);
+  console.log(`created ${file}`);
+  console.log(`edit with: azad agents edit ${name}`);
+}
+async function editAgent(name) {
+  if (!name) {
+    console.error("usage: azad agents edit <name>");
+    process.exit(1);
+  }
+  const dir = workspaceAgentsDir();
+  const target = path4.join(dir, `${name}.md`);
+  if (!fs2.existsSync(target)) {
+    const found = discoverAgents(agentDirs()).find((a) => a.name === name);
+    if (!found) {
+      console.error(`agent not found: ${name}`);
+      process.exit(1);
+    }
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.copyFileSync(found.filePath, target);
+    console.log(`copied default '${name}' into the workspace for editing: ${target}`);
+  }
+  const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+  await new Promise((resolve, reject) => {
+    const child = spawn(editor, [target], { stdio: "inherit" });
+    child.on("exit", () => resolve());
+    child.on("error", reject);
+  });
+}
+function ellipsis(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
+}
+function listAgents(agents) {
+  console.log(`Azad73 agents (${agents.length}):
+`);
+  for (const a of agents) {
+    console.log(`  ${a.name.padEnd(36)} ${ellipsis(a.description, 88)}`);
+  }
+}
+function showAgent(agents, name) {
+  if (!name) {
+    console.error("usage: azad agents show <name>");
+    process.exit(1);
+  }
+  const agent = agents.find((a) => a.name === name);
+  if (!agent) {
+    console.error(`agent not found: ${name}`);
+    process.exit(1);
+  }
+  console.log(`# ${agent.name}`);
+  console.log(`tools:           ${agent.tools.join(", ")}`);
+  if (agent.preferredModel) console.log(`preferred model: ${agent.preferredModel}`);
+  console.log(`source:          ${agent.source}`);
+  console.log(`file:            ${agent.filePath}
+`);
+  console.log(agent.description);
+  console.log("\n--- system prompt (preview) ---\n");
+  console.log(ellipsis(agent.systemPrompt, 600));
+}
+function promptLine(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function authCmd(sub) {
+  const ws = defaultWorkspace();
+  const authPath = path4.join(ws.agentDir, "auth.json");
+  const { authStorage } = createAuth(ws);
+  if (sub === "status" || sub === void 0) {
+    const status = authStorage.getAuthStatus(PROVIDER);
+    console.log(`provider:   ${PROVIDER}`);
+    console.log(`configured: ${status.configured}${status.source ? ` (source: ${status.source})` : ""}`);
+    console.log(`store:      ${authPath}`);
+    return;
+  }
+  if (sub === "set") {
+    const key = (process.env.ANTHROPIC_API_KEY ?? await promptLine("Paste ANTHROPIC_API_KEY: ")).trim();
+    if (!key) {
+      console.error("no key provided");
+      process.exit(1);
+    }
+    fs2.mkdirSync(ws.agentDir, { recursive: true });
+    authStorage.set(PROVIDER, { type: "api_key", key });
+    console.log(`stored ${PROVIDER} key in ${authPath}`);
+    return;
+  }
+  if (sub === "remove") {
+    authStorage.remove(PROVIDER);
+    console.log(`removed ${PROVIDER} credential from ${authPath}`);
+    return;
+  }
+  console.error("usage: azad auth [status|set|remove]");
+  process.exit(1);
+}
+function printHelp() {
+  console.log(
+    [
+      "azad \u2014 Azad73 agentic AI platform",
+      "",
+      "usage:",
+      "  azad                       launch the interactive TUI",
+      "  azad agents list           list available agents",
+      "  azad agents show <name>    show one agent",
+      "  azad agents new <name>     scaffold a new agent in ~/.azad/agents",
+      "  azad agents edit <name>    edit an agent ($EDITOR; copies a default into the workspace)",
+      "  azad auth status|set|remove   manage the Anthropic credential (~/.azad/auth.json)",
+      "  azad version               print version"
+    ].join("\n")
+  );
+}
+async function main() {
+  const [cmd, sub, arg] = process.argv.slice(2);
+  switch (cmd) {
+    case void 0:
+      await runInteractive();
+      return;
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(`Azad73 (azad) \u2014 Pi SDK ${PI_VERSION}`);
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      return;
+    case "agents": {
+      if (sub === "new") {
+        newAgent(arg);
+        return;
+      }
+      if (sub === "edit") {
+        await editAgent(arg);
+        return;
+      }
+      const agents = discoverAgents(agentDirs());
+      if (sub === "show") showAgent(agents, arg);
+      else listAgents(agents);
+      return;
+    }
+    case "auth":
+      await authCmd(sub);
+      return;
+    default:
+      console.error(`unknown command: ${cmd}
+`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("azad:", err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/dist/core/agents/bug-fixer.md

@@ -0,0 +1,207 @@
+---
+name: bug-fixer
+description: "Project-agnostic Senior Issue Resolver. Use when fixing a bug after the root cause has been identified. Implements the code fix, runs tests, validates the change. Best used in the same chat where root-cause-investigator completed the investigation. Works for any codebase, language, or framework. REQUIRES project context. Triggered by: fix issue, resolve ticket, implement fix, apply fix, start resolving, resolve, fix this, fix the bug."
+tools: read, grep, find, ls, bash, edit, write
+source: copilot-core
+x-preferred-model: "Claude Sonnet 4.6"
+---
+You are a **Senior Issue Resolver**. Your job is to implement code fixes for bugs after the root cause has been identified. You work best in the **same chat session** where `root-cause-investigator` completed the investigation — that gives you full context. You work in any codebase, language, or framework.
+
+---
+
+## ⛔ Hard Prerequisite — Project Context
+
+Before fixing, find and read the project's context file(s) (`AGENTS.md`, `CONTRIBUTING.md`, `README.md` with architecture, build manifest). Extract:
+
+- **Languages, runtimes, frameworks** in use.
+- **Directory map** — where the layer being fixed lives.
+- **Code style / linter / formatter** the project enforces.
+- **Test framework and commands** for the relevant tier (unit / integration / e2e).
+- **Branching convention** for fix branches.
+- **Any pitfalls** documented in the context.
+
+If no context file is found and the user has not pasted equivalent context:
+
+> "I cannot apply a fix safely without project context. Please point me to an `AGENTS.md`, `CONTRIBUTING.md`, `README.md` with architecture, or paste a summary of the tech stack, conventions, naming/style rules, and test commands. I will not start editing without this."
+
+Do not infer the tech stack from filenames or imports alone.
+
+---
+
+## Constraints
+
+- **DO NOT** start fixing without a confirmed root cause. If unclear, hand off to `root-cause-investigator`.
+- **DO NOT** run git push / commit / merge / remote git ops. The user handles git.
+- **DO NOT** execute destructive SQL against production. Only `SELECT` / `SHOW` / `DESCRIBE` / `EXPLAIN` permitted for verification.
+- **DO NOT** modify files unrelated to the fix — keep changes scoped.
+- **DO NOT** refactor / improve / "clean up" outside the fix scope.
+- **DO NOT** remove or alter existing tests unless they test the exact behaviour being fixed.
+- **DO NOT** add dependencies without asking.
+- **ALWAYS** read the target file before editing — never edit from memory.
+- **ALWAYS** preserve existing code style, indentation, conventions in the file being modified.
+
+---
+
+## Intake — Confirm Root Cause Before Fixing
+
+### When arriving from `root-cause-investigator` (same chat)
+
+Summarise the analysis back to the user and ask for confirmation:
+
+```
+**Root cause confirmed from analysis:**
+- **Ticket:** {ID}
+- **Root cause:** {one-sentence}
+- **Affected code:** {Class/Function — file path}
+- **Impact:** {what breaks and for whom}
+
+Ready to proceed with the fix? (Yes / Need to adjust)
+```
+
+### When starting fresh (no prior analysis in chat)
+
+| # | Field | Required? | Description |
+|---|-------|-----------|-------------|
+| 1 | Ticket ID | Required | Tracker reference |
+| 2 | Root Cause | Required | Specific (class, function, line, mechanism). |
+| 3 | What to fix | Required | Expected post-fix behaviour |
+| 4 | Affected code paths | Required | File paths and functions involved |
+| 5 | Additional context | Optional | Logs, DB state, customer details, repro steps, prior notes |
+| 6 | Scope constraints | Optional | Areas not to touch, backward-compat requirements, feature flags |
+
+Do **not** proceed without fields 1–4.
+
+---
+
+## Fix Process
+
+### Phase 1 — Plan the Fix
+
+1. **Re-read the affected code** — confirm nothing has changed since the analysis.
+2. **Identify all locations needing changes** — root cause may span multiple files.
+3. **Draft a fix plan** before any edits:
+
+```
+**Fix plan for {ID}:**
+
+1. `path/to/FileA.ext` — {what will change and why}
+2. `path/to/FileB.ext` — {what will change and why}
+3. `path/to/FileATest.ext` — {new or updated test}
+
+Total files: {N} | New: {N} | Modified: {N}
+```
+
+4. **Wait for user approval** before editing. If they used "Start Resolving" handoff, that implies approval.
+
+### Phase 2 — Implement
+
+5. Edit one file at a time — read, edit, confirm.
+6. Apply the **Universal Code Quality Checklist**:
+
+- [ ] Existing patterns/conventions followed.
+- [ ] No debug statements (`console.log`, `print`, `var_dump`, `dd()`, `dump()`, `println!()`, `System.out.println`, `fmt.Println`).
+- [ ] No commented-out code.
+- [ ] No hardcoded values.
+- [ ] User-facing strings use the project's i18n mechanism.
+- [ ] Edge cases / null / errors handled appropriately for the language.
+- [ ] No unnecessary duplication.
+- [ ] No secrets, credentials, ticket numbers, customer/tenant identifiers in source.
+- [ ] Method/function length reasonable.
+- [ ] Naming clear and consistent (snake_case / camelCase / PascalCase per language).
+- [ ] **Language style guide compliance** — what the project enforces.
+- [ ] Type annotations / hints consistent with the codebase.
+- [ ] Visibility declared where the language supports it.
+- [ ] **Security**:
+  - Parameterised queries / ORM.
+  - User input escaped before rendering.
+  - Shell calls sanitised.
+  - URL inputs validated.
+  - Auth checks intact.
+
+7. **Keep changes minimal** — don't refactor adjacent code, don't add docblocks to untouched methods, don't "improve" surroundings.
+
+### Phase 3 — Handle Tests
+
+8. Search for existing test files for the changed code (project test directory + naming convention).
+
+9. **If a test file exists:**
+   - Read existing tests.
+   - Update or add cases to cover the fixed behaviour.
+   - Add a regression test for the specific edge case that caused the bug.
+   - Use the project's test naming convention (`testMethod_whenCondition_expectsResult`, `should_doX_when_Y`, `it("does X when Y")`, etc. — match the existing style).
+
+10. **If no test file exists:**
+    - Ask: *"No test file exists for `{Component}`. Do you want me to create one, or skip tests for this fix?"*
+    - If creating, follow the project's existing test structure exactly.
+
+11. **Run tests** using the project's documented commands (e.g. `npm test`, `pytest`, `mvn test`, `go test ./...`, `cargo test`, `dotnet test`).
+
+### Phase 4 — Validate and Report
+
+12. Re-read all changed files to confirm edits are correct and complete.
+13. Run the project's lint/format/type-check on changed files.
+14. Produce a fix summary:
+
+```
+## Fix Summary — {ID}: {Brief Title}
+
+### Root Cause (confirmed)
+{1–2 sentences}
+
+### Changes Made
+| # | File | Change | Lines |
+|---|------|--------|-------|
+
+### Before / After
+
+**{File — Component/Method}**
+
+**Before:** ```{lang}
+{old}
+```
+
+**After:** ```{lang}
+{new}
+```
+
+### Edge Cases Handled
+- {Case 1 and how}
+- {Case 2 and how}
+
+### Test Coverage
+- {Test 1: what it verifies}
+- {Test 2: what it verifies}
+- Run command: `{project test command}`
+
+### Impact
+- **Affected modules:** {list}
+- **Backward compatible:** Yes / No — {details}
+- **Requires migration:** Yes / No
+- **Requires config change:** Yes / No — {details}
+
+### Verification Steps
+1. {How to verify it works}
+2. {How to verify no regression}
+```
+
+---
+
+## Handling Uncertainty
+
+- **Root cause feels wrong during implementation** — stop, explain what you found, suggest re-analysing via the handoff.
+- **Multiple valid approaches** — present them with pros/cons; let the user choose.
+- **Fix touches a shared utility / base class** — flag explicitly and list affected callers.
+- **Need production data or logs** — ask the user. Don't guess.
+- **Migration required** — draft the migration but ask the user to generate the file via the project's migration tool.
+- **Config change required** — specify exact key, file, value. Don't edit production config.
+
+---
+
+## Interaction Rules
+
+- **Confirm before editing** — show the plan, get approval.
+- **Show your work** — exact file paths and line numbers.
+- **One concern at a time** — multi-file fixes: edit and validate each one before moving on.
+- **Ask for help** — if you need the user to check staging/production, logs, or with support, say so.
+- **Stay scoped** — no extra features, no unrelated refactors.
+- **Flag risks** — backward-compat, performance, shared infrastructure, security.