omni-pi 0.1.0

package/src/plans.ts

@@ -0,0 +1,247 @@
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import type { PlanEntry, PlanStatus } from "./contracts.js";
+import { OMNI_DIR } from "./contracts.js";
+
+const PLANS_DIR = "plans";
+const INDEX_FILE = "INDEX.md";
+const PROGRESS_FILE = "PROGRESS.md";
+
+function plansDir(rootDir: string): string {
+  return path.join(rootDir, OMNI_DIR, PLANS_DIR);
+}
+
+function indexPath(rootDir: string): string {
+  return path.join(rootDir, OMNI_DIR, PLANS_DIR, INDEX_FILE);
+}
+
+function progressPath(rootDir: string): string {
+  return path.join(rootDir, OMNI_DIR, PROGRESS_FILE);
+}
+
+function planFilePath(rootDir: string, planId: string): string {
+  return path.join(plansDir(rootDir), `${planId}.md`);
+}
+
+function generatePlanId(): string {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/gu, "");
+  const seq = now.toISOString().slice(11, 19).replace(/:/gu, "");
+  return `plan-${date}-${seq}`;
+}
+
+function renderPlanFile(
+  entry: PlanEntry,
+  description: string,
+  tasks: string[],
+): string {
+  const taskLines =
+    tasks.length > 0
+      ? tasks.map((t) => `- [ ] ${t}`).join("\n")
+      : "- [ ] Define tasks";
+  return `# ${entry.title}
+
+Status: ${entry.status}
+Created: ${entry.createdAt}
+
+## Description
+
+${description}
+
+## Tasks
+
+${taskLines}
+
+## Notes
+
+-
+`;
+}
+
+function parseIndexEntries(content: string): PlanEntry[] {
+  const entries: PlanEntry[] = [];
+  for (const line of content.split("\n")) {
+    const match = line.match(
+      /^\|\s*\[([^\]]+)\]\([^)]+\)\s*\|\s*([^|]+)\|\s*(\w+)\s*\|\s*([^|]+)\|\s*([^|]*)\|/u,
+    );
+    if (match) {
+      entries.push({
+        id: match[1].trim(),
+        title: match[2].trim(),
+        status: match[3].trim() as PlanStatus,
+        createdAt: match[4].trim(),
+        completedAt: match[5]?.trim() || undefined,
+      });
+    }
+  }
+  return entries;
+}
+
+function renderIndex(entries: PlanEntry[]): string {
+  const rows = entries.map((e) => {
+    const completed = e.completedAt ?? "";
+    return `| [${e.id}](${e.id}.md) | ${e.title} | ${e.status} | ${e.createdAt} | ${completed} |`;
+  });
+  return `# Plan Index
+
+| ID | Title | Status | Created | Completed |
+| --- | --- | --- | --- | --- |
+${rows.join("\n")}
+`;
+}
+
+export async function ensurePlansDir(rootDir: string): Promise<void> {
+  await mkdir(plansDir(rootDir), { recursive: true });
+}
+
+export async function readPlanIndex(rootDir: string): Promise<PlanEntry[]> {
+  try {
+    const content = await readFile(indexPath(rootDir), "utf8");
+    return parseIndexEntries(content);
+  } catch {
+    return [];
+  }
+}
+
+async function writeIndex(
+  rootDir: string,
+  entries: PlanEntry[],
+): Promise<void> {
+  await ensurePlansDir(rootDir);
+  await writeFile(indexPath(rootDir), renderIndex(entries), "utf8");
+}
+
+export async function createPlan(
+  rootDir: string,
+  title: string,
+  description: string,
+  tasks: string[],
+): Promise<PlanEntry> {
+  const id = generatePlanId();
+  const createdAt = new Date().toISOString().slice(0, 10);
+  const entry: PlanEntry = { id, title, status: "active", createdAt };
+
+  await ensurePlansDir(rootDir);
+  await writeFile(
+    planFilePath(rootDir, id),
+    renderPlanFile(entry, description, tasks),
+    "utf8",
+  );
+
+  const entries = await readPlanIndex(rootDir);
+  entries.push(entry);
+  await writeIndex(rootDir, entries);
+
+  return entry;
+}
+
+export async function updatePlanStatus(
+  rootDir: string,
+  planId: string,
+  status: PlanStatus,
+): Promise<PlanEntry | null> {
+  const entries = await readPlanIndex(rootDir);
+  const entry = entries.find((e) => e.id === planId);
+  if (!entry) return null;
+
+  entry.status = status;
+  if (status === "completed" || status === "discarded") {
+    entry.completedAt = new Date().toISOString().slice(0, 10);
+  }
+
+  await writeIndex(rootDir, entries);
+
+  // Update status in the plan file itself
+  try {
+    const filePath = planFilePath(rootDir, planId);
+    const content = await readFile(filePath, "utf8");
+    const updated = content.replace(/^Status:\s*.+$/mu, `Status: ${status}`);
+    await writeFile(filePath, updated, "utf8");
+  } catch {
+    // file may have been cleaned up already
+  }
+
+  return entry;
+}
+
+export async function cleanupCompletedPlans(
+  rootDir: string,
+): Promise<string[]> {
+  const entries = await readPlanIndex(rootDir);
+  const toRemove = entries.filter(
+    (e) => e.status === "completed" || e.status === "discarded",
+  );
+  const removed: string[] = [];
+
+  for (const entry of toRemove) {
+    try {
+      await unlink(planFilePath(rootDir, entry.id));
+      removed.push(entry.id);
+    } catch {
+      // already gone
+    }
+  }
+
+  // Keep entries in index but mark them — files are gone
+  await writeIndex(rootDir, entries);
+  return removed;
+}
+
+export async function appendProgress(
+  rootDir: string,
+  message: string,
+): Promise<void> {
+  const filePath = progressPath(rootDir);
+  const timestamp = new Date().toISOString().slice(0, 16).replace("T", " ");
+  const bullet = `- [${timestamp}] ${message}`;
+
+  try {
+    const content = await readFile(filePath, "utf8");
+    await writeFile(filePath, `${content.trimEnd()}\n${bullet}\n`, "utf8");
+  } catch {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(
+      filePath,
+      `# Progress\n\nOngoing log of project progress.\n\n${bullet}\n`,
+      "utf8",
+    );
+  }
+}
+
+export async function readProgress(rootDir: string): Promise<string> {
+  try {
+    return await readFile(progressPath(rootDir), "utf8");
+  } catch {
+    return "No progress recorded yet.";
+  }
+}
+
+export function renderPlanIndex(entries: PlanEntry[]): string {
+  if (entries.length === 0) return "No plans created yet.";
+
+  const active = entries.filter((e) => e.status === "active");
+  const completed = entries.filter((e) => e.status === "completed");
+  const discarded = entries.filter((e) => e.status === "discarded");
+
+  const lines: string[] = [];
+  if (active.length > 0) {
+    lines.push("Active:");
+    for (const e of active) {
+      lines.push(`  ${e.id}: ${e.title} (since ${e.createdAt})`);
+    }
+  }
+  if (completed.length > 0) {
+    lines.push("Completed:");
+    for (const e of completed) {
+      lines.push(`  ${e.id}: ${e.title} (done ${e.completedAt})`);
+    }
+  }
+  if (discarded.length > 0) {
+    lines.push("Discarded:");
+    for (const e of discarded) {
+      lines.push(`  ${e.id}: ${e.title}`);
+    }
+  }
+  return lines.join("\n");
+}

package/src/repo.ts

@@ -0,0 +1,210 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+
+export interface RepoSignals {
+  languages: string[];
+  frameworks: string[];
+  tools: string[];
+  files: string[];
+}
+
+async function exists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readPackageJson(
+  rootDir: string,
+): Promise<Record<string, unknown> | null> {
+  const packageJsonPath = path.join(rootDir, "package.json");
+  if (!(await exists(packageJsonPath))) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(await readFile(packageJsonPath, "utf8")) as Record<
+      string,
+      unknown
+    >;
+  } catch {
+    return null;
+  }
+}
+
+function gatherPackageNames(pkg: Record<string, unknown> | null): string[] {
+  if (!pkg) {
+    return [];
+  }
+
+  const sections = ["dependencies", "devDependencies", "peerDependencies"];
+  const names = new Set<string>();
+
+  for (const section of sections) {
+    const value = pkg[section];
+    if (value && typeof value === "object") {
+      for (const key of Object.keys(value as Record<string, unknown>)) {
+        names.add(key);
+      }
+    }
+  }
+
+  return [...names];
+}
+
+export async function detectRepoSignals(rootDir: string): Promise<RepoSignals> {
+  const filesToCheck = [
+    "package.json",
+    "Cargo.toml",
+    "go.mod",
+    "requirements.txt",
+    "pyproject.toml",
+    "setup.py",
+    "Gemfile",
+    "composer.json",
+    "mix.exs",
+    "build.gradle",
+    "build.gradle.kts",
+    "pom.xml",
+    "Makefile",
+    "CMakeLists.txt",
+    "Package.swift",
+    "playwright.config.ts",
+    "playwright.config.js",
+    "cypress.config.ts",
+    "cypress.config.js",
+    "vite.config.ts",
+    "next.config.js",
+    "next.config.mjs",
+    "tsconfig.json",
+    "pytest.ini",
+    "setup.cfg",
+    "tox.ini",
+    ".rspec",
+  ];
+
+  const presentFiles = (
+    await Promise.all(
+      filesToCheck.map(async (file) =>
+        (await exists(path.join(rootDir, file))) ? file : null,
+      ),
+    )
+  ).filter((value): value is string => value !== null);
+
+  const packageJson = await readPackageJson(rootDir);
+  const packageNames = gatherPackageNames(packageJson);
+
+  const languages = new Set<string>();
+  const frameworks = new Set<string>();
+  const tools = new Set<string>();
+
+  if (presentFiles.includes("Cargo.toml")) {
+    languages.add("rust");
+  }
+
+  if (
+    presentFiles.includes("tsconfig.json") ||
+    packageNames.some((name) => name.includes("typescript"))
+  ) {
+    languages.add("typescript");
+  }
+
+  if (presentFiles.includes("go.mod")) {
+    languages.add("go");
+  }
+
+  if (
+    presentFiles.includes("requirements.txt") ||
+    presentFiles.includes("pyproject.toml") ||
+    presentFiles.includes("setup.py")
+  ) {
+    languages.add("python");
+  }
+
+  if (presentFiles.includes("Gemfile")) {
+    languages.add("ruby");
+  }
+
+  if (presentFiles.includes("composer.json")) {
+    languages.add("php");
+  }
+
+  if (presentFiles.includes("mix.exs")) {
+    languages.add("elixir");
+  }
+
+  if (
+    presentFiles.includes("build.gradle") ||
+    presentFiles.includes("build.gradle.kts") ||
+    presentFiles.includes("pom.xml")
+  ) {
+    languages.add("java");
+  }
+
+  if (presentFiles.includes("Package.swift")) {
+    languages.add("swift");
+  }
+
+  if (
+    presentFiles.includes("CMakeLists.txt") &&
+    !presentFiles.includes("Cargo.toml")
+  ) {
+    languages.add("cpp");
+  }
+
+  if (presentFiles.includes("pytest.ini") || presentFiles.includes("tox.ini")) {
+    tools.add("pytest");
+  }
+
+  if (presentFiles.includes(".rspec")) {
+    tools.add("rspec");
+  }
+
+  if (presentFiles.includes("Makefile")) {
+    tools.add("make");
+  }
+
+  if (packageNames.includes("react") || packageNames.includes("next")) {
+    frameworks.add("react");
+  }
+
+  if (
+    packageNames.includes("next") ||
+    presentFiles.some((file) => file.startsWith("next.config"))
+  ) {
+    frameworks.add("nextjs");
+  }
+
+  if (
+    packageNames.includes("vite") ||
+    presentFiles.includes("vite.config.ts")
+  ) {
+    tools.add("vite");
+  }
+
+  if (presentFiles.some((file) => file.startsWith("playwright.config"))) {
+    tools.add("playwright");
+  }
+
+  if (presentFiles.some((file) => file.startsWith("cypress.config"))) {
+    tools.add("cypress");
+  }
+
+  if (packageNames.includes("vitest")) {
+    tools.add("vitest");
+  }
+
+  if (packageNames.includes("jest")) {
+    tools.add("jest");
+  }
+
+  return {
+    languages: [...languages].sort(),
+    frameworks: [...frameworks].sort(),
+    tools: [...tools].sort(),
+    files: presentFiles.sort(),
+  };
+}