peer-ai 1.0.0-next.0

package/dist/work.d.ts

@@ -0,0 +1,147 @@
+import { type ActivityId, type KnownMapItemId, type PeerAiConfig, type ReviewResult, type SkillId, type WorkItem } from "peer-ai-workflow";
+import { reviewsToDo } from "./routing.ts";
+import type { Output, Stage } from "./init.ts";
+export declare const WORK_ITEM_SCHEMA_URL = "https://raw.githubusercontent.com/AbuMahir980/peer-ai/main/packages/workflow/schemas/work-item.schema.json";
+export type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+export type ItemStage = WorkItem["stage"];
+export type ItemKind = WorkItem["kind"];
+export declare function loadWorkItem(root: string, id: string): Result<WorkItem>;
+/** The next free id: the tracker's ticket prefix, or ITEM, and one more than the highest number. */
+export declare function nextId(root: string, config: PeerAiConfig): string;
+/** A branch name from the repo's naming pattern, when every placeholder in it is known. */
+export declare function branchFor(pattern: string | undefined, id: string, title: string): string | undefined;
+export interface NewWorkItem {
+    title: string;
+    kind: ItemKind;
+    id?: string | undefined;
+    track?: string | undefined;
+    gap?: string | undefined;
+    branch?: string | undefined;
+    next?: string | undefined;
+    goal?: string | undefined;
+    acceptance?: string[] | undefined;
+    sources?: string[] | undefined;
+    dependsOn?: string[] | undefined;
+}
+export declare function createWorkItem(root: string, config: PeerAiConfig, input: NewWorkItem, now: Date): Result<WorkItem>;
+export interface WorkItemChanges {
+    title?: string | undefined;
+    next?: string | undefined;
+    branch?: string | undefined;
+    position?: {
+        activity: ActivityId;
+        step: number;
+    } | undefined;
+    goal?: string | undefined;
+    acceptance?: string[] | undefined;
+    sources?: string[] | undefined;
+    dependsOn?: string[] | undefined;
+}
+export declare function updateWorkItem(root: string, config: PeerAiConfig, id: string, changes: WorkItemChanges, now: Date): Result<WorkItem>;
+export interface ReviewInput {
+    skill: SkillId;
+    /** Needed without a report. With one, it must match the result the report supports. */
+    result?: ReviewResult | undefined;
+    /** The review report, relative to the project root. */
+    report?: string | undefined;
+    summary?: string | undefined;
+}
+/**
+ * Records a review. With a report, Peer AI works the result out from it and refuses a result the
+ * report doesn't support (RFC 0002). Without one, the agent's result is recorded as unproven.
+ */
+export interface CheckedReport {
+    skill: SkillId;
+    result: ReviewResult;
+    report: string;
+    summary: string;
+}
+/**
+ * Checks a review's report: that it's valid, is for this skill (and work item, when there is one),
+ * gives every rule the skill answers for a line (RFC 0004), and claims the result its findings and
+ * coverage support.
+ */
+export declare function checkReport(root: string, config: PeerAiConfig, review: ReviewInput & {
+    report: string;
+}, workItem?: string): Result<CheckedReport>;
+export interface CheckReportOptions {
+    cwd: string;
+    /** The report's path, relative to the project root. */
+    report: string;
+    /** The skill it's for. Defaults to the skill the report names. */
+    skill?: string | undefined;
+    /** The work item it's for, when there is one. */
+    workItem?: string | undefined;
+    json: boolean;
+}
+/**
+ * peer-ai check-report: the same checks as the record_review tool, for a model or a person that
+ * works in a shell. Exit code 0 when the report passes them; 1 when it doesn't; 2 without a config.
+ */
+export declare function runCheckReport(options: CheckReportOptions, out: Output): number;
+export declare function recordReview(root: string, config: PeerAiConfig, id: string, review: ReviewInput, now: Date): Result<WorkItem>;
+export declare function recordVerify(root: string, config: PeerAiConfig, id: string, result: "pass" | "fail", now: Date): Result<WorkItem>;
+/**
+ * Moves a work item to `to`, or to the stage after its current one. It can move back to any
+ * earlier stage. A move to ship or done is refused, with what to fix, when the gates fail.
+ */
+export declare function advanceWorkItem(root: string, config: PeerAiConfig, id: string, to: ItemStage | undefined, now: Date): Result<WorkItem>;
+export interface CommandResult {
+    code: number | null;
+    /** The end of the combined output, which is where test runners report what failed. */
+    output: string;
+}
+export type CommandRunner = (command: string, cwd: string) => Promise<CommandResult>;
+/** Runs a command from the project's config through the shell, as a person would type it. */
+export declare const runCommand: CommandRunner;
+export interface VerifyOutcome {
+    item: WorkItem;
+    command: string;
+    result: "pass" | "fail";
+    output: string;
+}
+/** Runs commands.verify and records the result, so a pass is proven rather than claimed. */
+export declare function runVerify(root: string, config: PeerAiConfig, id: string, now: () => Date, run?: CommandRunner): Promise<Result<VerifyOutcome>>;
+/** The checked-out branch, even before the first commit; undefined when detached or not in git. */
+export declare function currentBranch(root: string): string | undefined;
+/** A setup problem doctor finds, for the AI tool to fix or tell the person about before other work. */
+export interface SetupProblem {
+    check: string;
+    status: "fail" | "warn";
+    message: string;
+    fix?: string;
+}
+export interface NextWork {
+    /** Every setup problem doctor finds (RFC 0007). Absent when there is none. */
+    setup?: {
+        problems: SetupProblem[];
+    };
+    branch?: string;
+    /** The open work item for the current branch. */
+    current?: WorkItem;
+    /** Every open work item, most recently updated first. */
+    open: WorkItem[];
+    /** The current item's required reviews, by the names their skills are installed under. */
+    reviews?: ReturnType<typeof reviewsToDo>;
+    /** For each open item with unfinished dependencies, the items it's waiting for before it can ship (RFC 0005). */
+    waiting?: Record<string, string[]>;
+    /**
+     * When nothing is open: what the project's stage still needs, to start as gap work items, and
+     * the skill to use for each gap that has one.
+     */
+    gaps?: {
+        stage: Stage;
+        needed: KnownMapItemId[];
+        later: KnownMapItemId[];
+        useSkill: Partial<Record<KnownMapItemId, string>>;
+    };
+}
+/** Doctor's failures and warnings, as next_work reports them. */
+export declare function setupProblems(root: string, nodeVersion?: string, today?: Date): SetupProblem[];
+export declare function nextWork(root: string, config: PeerAiConfig): NextWork;

package/dist/work.js

@@ -0,0 +1,357 @@
+// Work items: create them, record where work stands, verify and review them, and move them
+// through their stages. Every change is validated against the work item schema before it is
+// written, and a move to ship or done must pass the same gates as `peer-ai check`, so what an
+// agent records is what CI will accept.
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { availableSkills, skillRuleIds } from "peer-ai-skills";
+import { SKILL_IDS, deriveResult, validateReport, validateWorkItem, } from "peer-ai-workflow";
+import { NEXT_STAGE, assess, gaps, loadConfig } from "./assess.js";
+import { gateWorkItem } from "./check.js";
+import { CONFIG_FILE } from "./detect.js";
+import { diagnose } from "./doctor.js";
+import { changedFiles, gapSkills, reviewsFor, reviewsToDo } from "./routing.js";
+import { WORK_DIR, readWorkItems } from "./state.js";
+export const WORK_ITEM_SCHEMA_URL = "https://raw.githubusercontent.com/AbuMahir980/peer-ai/main/packages/workflow/schemas/work-item.schema.json";
+/** The order work moves through. cancelled can be reached from any stage before done. */
+const ORDER = ["prepare", "build", "verify", "ship", "done"];
+const CLOSED = ["done", "cancelled"];
+const DEFAULT_PREFIX = "ITEM";
+const failed = (error) => ({ ok: false, error });
+const projectStage = (config) => config.project.stage ?? "mvp";
+function tracksOf(config) {
+    return config.tracks.map((track) => track.id);
+}
+export function loadWorkItem(root, id) {
+    const file = readWorkItems(root).find(({ path }) => path === `${WORK_DIR}/${id}.json`);
+    if (file === undefined)
+        return failed(`There is no work item "${id}".`);
+    return file.item.ok ? file.item : failed(`${file.path} ${file.item.error}`);
+}
+function save(root, config, item) {
+    const result = validateWorkItem({ $schema: WORK_ITEM_SCHEMA_URL, ...item });
+    if (!result.ok)
+        return failed(`The work item would not be valid: ${result.errors.join("; ")}`);
+    if (item.track !== undefined && !tracksOf(config).includes(item.track)) {
+        return failed(`There is no track "${item.track}". The tracks are: ${tracksOf(config).join(", ")}.`);
+    }
+    mkdirSync(join(root, WORK_DIR), { recursive: true });
+    writeFileSync(join(root, WORK_DIR, `${item.id}.json`), `${JSON.stringify(result.value, null, 2)}\n`);
+    return result;
+}
+/** The next free id: the tracker's ticket prefix, or ITEM, and one more than the highest number. */
+export function nextId(root, config) {
+    const prefix = (config.tracker?.ticketPrefix ?? DEFAULT_PREFIX).replace(/-+$/, "");
+    const pattern = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}-(\\d+)$`);
+    const numbers = readWorkItems(root).flatMap(({ path }) => {
+        const match = pattern.exec(path.slice(WORK_DIR.length + 1, -".json".length));
+        return match?.[1] === undefined ? [] : [Number(match[1])];
+    });
+    return `${prefix}-${String(Math.max(0, ...numbers) + 1)}`;
+}
+/** A branch name from the repo's naming pattern, when every placeholder in it is known. */
+export function branchFor(pattern, id, title) {
+    if (pattern === undefined)
+        return undefined;
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 50)
+        .replace(/-+$/, "");
+    const branch = pattern.replaceAll("{ticket}", id).replaceAll("{id}", id).replaceAll("{slug}", slug);
+    return /[{}]/.test(branch) ? undefined : branch;
+}
+export function createWorkItem(root, config, input, now) {
+    const id = input.id ?? nextId(root, config);
+    if (existsSync(join(root, WORK_DIR, `${id}.json`)))
+        return failed(`A work item "${id}" already exists.`);
+    const ownTracks = config.tracks.filter((track) => track.status !== "external");
+    // With a single track there is nothing to choose, so the item is on it.
+    const track = input.track ?? (ownTracks.length === 1 ? ownTracks[0]?.id : undefined);
+    const branch = input.branch ?? branchFor(config.repo?.branchNaming, id, input.title);
+    const item = {
+        version: 1,
+        id,
+        title: input.title,
+        kind: input.kind,
+        stage: "prepare",
+        ...(track === undefined ? {} : { track }),
+        ...(branch === undefined ? {} : { branch }),
+        ...(input.gap === undefined ? {} : { gap: input.gap }),
+        ...defined({ goal: input.goal, acceptance: input.acceptance, sources: input.sources, dependsOn: input.dependsOn }),
+        next: input.next ?? "Read what this item needs, then plan it.",
+        updatedAt: now.toISOString(),
+    };
+    return save(root, config, item);
+}
+/** The fields that have a value, so an undefined argument never erases a stored one. */
+const defined = (value) => Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined));
+export function updateWorkItem(root, config, id, changes, now) {
+    const loaded = loadWorkItem(root, id);
+    if (!loaded.ok)
+        return loaded;
+    return save(root, config, { ...loaded.value, ...defined(changes), updatedAt: now.toISOString() });
+}
+/** Reads a review report inside the project and checks it is valid. */
+function readReport(root, path) {
+    const full = resolve(root, path);
+    const inside = relative(root, full);
+    if (inside === "" || inside.startsWith("..") || isAbsolute(inside)) {
+        return failed(`${path} is outside the project. Save the report under .peer-ai/reports/.`);
+    }
+    if (!existsSync(full))
+        return failed(`There is no report at ${path}.`);
+    let json;
+    try {
+        json = JSON.parse(readFileSync(full, "utf8"));
+    }
+    catch (error) {
+        return failed(`${path} is not valid JSON: ${error.message}`);
+    }
+    const report = validateReport(json);
+    return report.ok ? report : failed(`${path} is not a valid review report:\n- ${report.errors.join("\n- ")}`);
+}
+/**
+ * Checks a review's report: that it's valid, is for this skill (and work item, when there is one),
+ * gives every rule the skill answers for a line (RFC 0004), and claims the result its findings and
+ * coverage support.
+ */
+export function checkReport(root, config, review, workItem) {
+    const read = readReport(root, review.report);
+    if (!read.ok)
+        return read;
+    const report = read.value;
+    if (report.skill !== review.skill) {
+        return failed(`The report is for ${report.skill}, not ${review.skill}.`);
+    }
+    if (workItem !== undefined && report.workItem !== undefined && report.workItem !== workItem) {
+        return failed(`The report is for work item ${report.workItem}, not ${workItem}.`);
+    }
+    // Silence is never an answer (RFC 0004): every rule the skill answers for gets a line, even
+    // one that doesn't apply here.
+    if (availableSkills().includes(review.skill)) {
+        const covered = new Set(report.coverage.map((line) => line.rule));
+        const missing = skillRuleIds(review.skill).filter((rule) => !covered.has(rule));
+        if (missing.length > 0) {
+            const shown = missing.length > 12
+                ? `${missing.slice(0, 12).join(", ")} and ${String(missing.length - 12)} more`
+                : missing.join(", ");
+            return failed(`The report leaves out ${String(missing.length)} of ${review.skill}'s rules: ${shown}. Give every rule a coverage line: mark one that doesn't apply as not-applicable, with the reason.`);
+        }
+    }
+    const blockOn = config.gates?.blockOn ?? "critical";
+    const worked = deriveResult(report, blockOn);
+    if (report.result !== worked) {
+        return failed(`The report says ${report.result}, but its findings and coverage make it ${worked} (blocking level: ${blockOn}). Correct the report's result.`);
+    }
+    if (review.result !== undefined && review.result !== worked) {
+        return failed(`You gave ${review.result}, but the report makes it ${worked}.`);
+    }
+    return {
+        ok: true,
+        value: { skill: review.skill, result: worked, report: review.report, summary: review.summary ?? report.summary },
+    };
+}
+/**
+ * peer-ai check-report: the same checks as the record_review tool, for a model or a person that
+ * works in a shell. Exit code 0 when the report passes them; 1 when it doesn't; 2 without a config.
+ */
+export function runCheckReport(options, out) {
+    const { config, errors } = loadConfig(options.cwd);
+    if (config === undefined) {
+        out.error(errors === undefined ? `There is no ${CONFIG_FILE}. Run peer-ai init first.` : `${CONFIG_FILE} is not valid.`);
+        return 2;
+    }
+    let skill = options.skill;
+    if (skill === undefined) {
+        try {
+            const named = JSON.parse(readFileSync(resolve(options.cwd, options.report), "utf8"))
+                .skill;
+            if (typeof named === "string")
+                skill = named;
+        }
+        catch {
+            // Unreadable or not JSON: checkReport says which.
+        }
+    }
+    if (skill === undefined || !SKILL_IDS.includes(skill)) {
+        const problem = `The report doesn't name one of Peer AI's skills as its "skill", such as "security-review": give it with --skill, and put it in the report.`;
+        if (options.json)
+            out.log(JSON.stringify({ ok: false, error: problem }, null, 2));
+        else
+            out.error(`✗ ${problem}`);
+        return 1;
+    }
+    const checked = checkReport(options.cwd, config, { skill: skill, report: options.report }, options.workItem);
+    if (options.json) {
+        out.log(JSON.stringify(checked.ok ? { ok: true, ...checked.value } : { ok: false, error: checked.error }, null, 2));
+    }
+    else if (checked.ok) {
+        out.log(`✓ ${options.report} passes Peer AI's checks. Its result is ${checked.value.result}.`);
+    }
+    else {
+        out.error(`✗ ${checked.error}`);
+    }
+    return checked.ok ? 0 : 1;
+}
+export function recordReview(root, config, id, review, now) {
+    const loaded = loadWorkItem(root, id);
+    if (!loaded.ok)
+        return loaded;
+    const at = now.toISOString();
+    let entry;
+    if (review.report === undefined) {
+        if (review.result === undefined)
+            return failed("Give the review's result, or the report to work it out from.");
+        const summary = review.summary === undefined ? {} : { summary: review.summary };
+        entry = { skill: review.skill, result: review.result, ...summary, unproven: true, at };
+    }
+    else {
+        const checked = checkReport(root, config, { ...review, report: review.report }, id);
+        if (!checked.ok)
+            return checked;
+        entry = { ...checked.value, at };
+    }
+    const reviews = [...(loaded.value.reviews ?? []), entry];
+    return save(root, config, { ...loaded.value, reviews, updatedAt: at });
+}
+export function recordVerify(root, config, id, result, now) {
+    const loaded = loadWorkItem(root, id);
+    if (!loaded.ok)
+        return loaded;
+    const at = now.toISOString();
+    return save(root, config, { ...loaded.value, lastVerify: { result, at }, updatedAt: at });
+}
+/**
+ * Moves a work item to `to`, or to the stage after its current one. It can move back to any
+ * earlier stage. A move to ship or done is refused, with what to fix, when the gates fail.
+ */
+export function advanceWorkItem(root, config, id, to, now) {
+    const loaded = loadWorkItem(root, id);
+    if (!loaded.ok)
+        return loaded;
+    const item = loaded.value;
+    if (CLOSED.includes(item.stage) && (to === undefined || to === item.stage)) {
+        return failed(`${item.id} is already ${item.stage}.`);
+    }
+    const target = to ?? ORDER[ORDER.indexOf(item.stage) + 1];
+    if (target === undefined)
+        return failed(`${item.id} has no stage after ${item.stage}.`);
+    if (target === "verify") {
+        // The reviews it needs are worked out once, from what the change touched, and kept on the item
+        // so CI can hold it to them without the branch's history.
+        const read = (file) => {
+            try {
+                return readFileSync(join(root, file), "utf8");
+            }
+            catch {
+                return "";
+            }
+        };
+        const requiredReviews = reviewsFor(changedFiles(root), config, projectStage(config), read, undefined, item);
+        return save(root, config, { ...item, stage: target, requiredReviews, updatedAt: now.toISOString() });
+    }
+    if (target === "ship" || target === "done") {
+        const moved = { ...item, stage: target };
+        const stage = projectStage(config);
+        const others = readWorkItems(root).flatMap(({ item: other }) => (other.ok ? [other.value] : []));
+        const failures = gateWorkItem(moved, config, stage, assess(root, config, stage), others).filter((check) => check.status === "fail");
+        if (failures.length > 0) {
+            const reasons = failures.map((check) => `- ${check.message} ${check.fix ?? ""}`.trimEnd());
+            return failed(`${item.id} can't move to ${target} yet:\n${reasons.join("\n")}`);
+        }
+    }
+    return save(root, config, { ...item, stage: target, updatedAt: now.toISOString() });
+}
+const OUTPUT_KEPT = 4000;
+const VERIFY_TIMEOUT_MS = 30 * 60 * 1000;
+/** Runs a command from the project's config through the shell, as a person would type it. */
+export const runCommand = (command, cwd) => new Promise((resolve) => {
+    let output = "";
+    const keep = (chunk) => {
+        output = (output + chunk.toString("utf8")).slice(-OUTPUT_KEPT);
+    };
+    // stdin is closed, so a command that waits for input ends instead of hanging until the
+    // timeout; output is piped, never inherited, because stdout carries the MCP protocol.
+    const child = spawn(command, { cwd, shell: true, timeout: VERIFY_TIMEOUT_MS, stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.on("data", keep);
+    child.stderr.on("data", keep);
+    child.on("error", (error) => {
+        resolve({ code: null, output: `${output}\n${error.message}`.trim() });
+    });
+    child.on("close", (code) => {
+        resolve({ code, output });
+    });
+});
+/** Runs commands.verify and records the result, so a pass is proven rather than claimed. */
+export async function runVerify(root, config, id, now, run = runCommand) {
+    const loaded = loadWorkItem(root, id);
+    if (!loaded.ok)
+        return loaded;
+    const command = config.commands?.verify ?? undefined;
+    if (command === undefined) {
+        return failed("There is no verify command. Set commands.verify in peer-ai.config.json to the command that checks the project, such as its tests and linter.");
+    }
+    const { code, output } = await run(command, root);
+    const result = code === 0 ? "pass" : "fail";
+    const recorded = recordVerify(root, config, id, result, now());
+    return recorded.ok ? { ok: true, value: { item: recorded.value, command, result, output } } : recorded;
+}
+/** The checked-out branch, even before the first commit; undefined when detached or not in git. */
+export function currentBranch(root) {
+    try {
+        const branch = execFileSync("git", ["symbolic-ref", "--short", "-q", "HEAD"], {
+            cwd: root,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return branch === "" ? undefined : branch;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Doctor's failures and warnings, as next_work reports them. */
+export function setupProblems(root, nodeVersion, today) {
+    return diagnose(root, nodeVersion, today).checks.flatMap((check) => check.status === "fail" || check.status === "warn"
+        ? [
+            {
+                check: check.id,
+                status: check.status,
+                message: check.message,
+                ...(check.fix === undefined ? {} : { fix: check.fix }),
+            },
+        ]
+        : []);
+}
+export function nextWork(root, config) {
+    const problems = setupProblems(root);
+    const branch = currentBranch(root);
+    const open = readWorkItems(root)
+        .flatMap(({ item }) => (item.ok && !CLOSED.includes(item.value.stage) ? [item.value] : []))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    const current = branch === undefined ? undefined : open.find((item) => item.branch === branch);
+    const reviews = current === undefined ? [] : reviewsToDo(current);
+    const shipped = new Set(readWorkItems(root).flatMap(({ item }) => item.ok && (item.value.stage === "ship" || item.value.stage === "done") ? [item.value.id] : []));
+    const waiting = Object.fromEntries(open
+        .map((item) => [item.id, (item.dependsOn ?? []).filter((id) => !shipped.has(id))])
+        .filter(([, unfinished]) => unfinished.length > 0));
+    const result = {
+        ...(problems.length === 0 ? {} : { setup: { problems } }),
+        ...(branch === undefined ? {} : { branch }),
+        ...(current ? { current } : {}),
+        ...(reviews.length > 0 ? { reviews } : {}),
+        ...(Object.keys(waiting).length > 0 ? { waiting } : {}),
+        open,
+    };
+    if (open.length > 0)
+        return result;
+    const stage = projectStage(config);
+    const assessment = assess(root, config, stage);
+    const next = NEXT_STAGE[stage];
+    const needed = gaps(assessment, stage);
+    const later = next === undefined ? [] : gaps(assessment, next).filter((id) => !needed.includes(id));
+    return { ...result, gaps: { stage, needed, later, useSkill: gapSkills([...needed, ...later]) } };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "peer-ai",
+  "version": "1.0.0-next.0",
+  "description": "Keeps AI coding tools to a senior team's standard: planning, testing, security and compliance, with proof of every check",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "peer-ai": "./dist/cli.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.8.1",
+    "@modelcontextprotocol/sdk": "1.30.1",
+    "peer-ai-skills": "1.0.0-next.0",
+    "peer-ai-standards": "1.0.0-next.0",
+    "peer-ai-workflow": "1.0.0-next.0",
+    "jsonc-parser": "3.3.1",
+    "smol-toml": "1.9.0",
+    "yaml": "2.9.1",
+    "zod": "4.6.5"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "devDependencies": {
+    "@astral-sh/ruff-wasm-nodejs": "0.16.9"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AbuMahir980/peer-ai.git",
+    "directory": "packages/peer-ai"
+  },
+  "homepage": "https://github.com/AbuMahir980/peer-ai#readme",
+  "bugs": {
+    "url": "https://github.com/AbuMahir980/peer-ai/issues"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  }
+}