@shanvit7/poiesis 0.1.0

package/src/utils.ts

@@ -0,0 +1,164 @@
+import { execSync } from "node:child_process"
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import type { ChapterState, ChapterStep } from "./types.ts"
+
+export const slugify = (s: string): string =>
+  s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40)
+
+export const expandHome = (p: string): string => p.replace(/^~/, process.env.HOME ?? "")
+
+/**
+ * Scan $HOME for directories that actually exist — used to build ask_user_question options
+ * for the project location picker. Returns at most 4 (the tool's max per question).
+ */
+export const scanHomeDirs = (): { label: string; path: string }[] => {
+  const home = process.env.HOME ?? ""
+  const candidates = ["Desktop", "projects", "dev", "code", "Documents", "workspace", "src"]
+  return candidates
+    .filter((name) => existsSync(`${home}/${name}`))
+    .slice(0, 4)
+    .map((name) => ({ label: name, path: `${home}/${name}` }))
+}
+
+export const readJson = <T>(path: string): T => {
+  const full = expandHome(path)
+  return JSON.parse(readFileSync(full, "utf8")) as T
+}
+
+export const writeJson = (path: string, data: unknown): void => {
+  const full = expandHome(path)
+  mkdirSync(dirname(full), { recursive: true })
+  writeFileSync(full, JSON.stringify(data, null, 2))
+}
+
+export const exists = (path: string): boolean => existsSync(expandHome(path))
+
+export const run = (cmd: string, cwd?: string): string => {
+  try {
+    return execSync(cmd, {
+      cwd: cwd ? expandHome(cwd) : undefined,
+      encoding: "utf8",
+      stdio: ["inherit", "pipe", "pipe"],
+    }).trim()
+  } catch (e: unknown) {
+    const err = e as { stderr?: Buffer; message?: string }
+    throw new Error(`Command failed: ${cmd}\n${err.stderr?.toString() ?? err.message ?? ""}`)
+  }
+}
+
+export const ensureDir = (path: string): void => {
+  mkdirSync(expandHome(path), { recursive: true })
+}
+
+// ── Chapter step state ──────────────────────────────────────────────────────────────────
+
+export const chapterStatePath = (projectDir: string, n: number): string =>
+  join(expandHome(projectDir), ".poiesis", "chapters", `chapter-${n}.state.json`)
+
+export const readChapterState = (projectDir: string, n: number): ChapterState | null => {
+  const p = chapterStatePath(projectDir, n)
+  if (!existsSync(p)) return null
+  return readJson<ChapterState>(p)
+}
+
+/** Deep-merges patch into existing state, or creates from defaults. */
+export const writeChapterState = (
+  projectDir: string,
+  n: number,
+  patch: Partial<ChapterState>
+): void => {
+  const existing = readChapterState(projectDir, n) ?? {
+    step: "prereq" as ChapterStep,
+    prereqResult: null,
+    testsFile: null,
+    testsPlan: [],
+    testsPass: false,
+    startedAt: new Date().toISOString(),
+  }
+  writeJson(chapterStatePath(projectDir, n), { ...existing, ...patch })
+}
+
+/**
+ * Find a poiesis project directory that has an active .progress.json.
+ *
+ * Two-pass:
+ * 1. cwd itself is the project root (user is already inside it)
+ * 2. scan immediate children of cwd (user is in the parent)
+ */
+export const findActiveProject = (cwd: string): string | null => {
+  const base = expandHome(cwd)
+
+  // Pass 1: cwd is the project itself
+  if (existsSync(join(base, ".poiesis", "chapters", ".progress.json"))) return base
+
+  // Pass 2: scan one level down
+  let entries: import("node:fs").Dirent[]
+  try {
+    entries = readdirSync(base, { withFileTypes: true })
+  } catch {
+    return null
+  }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue
+    if (existsSync(join(base, e.name, ".poiesis", "chapters", ".progress.json")))
+      return join(base, e.name)
+  }
+  return null
+}
+
+// ponytail: self-check
+if (process.argv[1]?.endsWith("utils.ts")) {
+  import("node:os").then(({ tmpdir }) => {
+    import("node:fs").then(({ mkdirSync, writeFileSync, rmSync }) => {
+      const s = slugify("Build a Rust HTTP Server from Scratch!!")
+      console.assert(s === "build-a-rust-http-server-from-scratch", `slugify failed: ${s}`)
+
+      // Pass 2: cwd is the parent, project is a child dir
+      const tmp = join(tmpdir(), `poiesis-utils-${Date.now()}`)
+      const projDir = join(tmp, "my-project", ".poiesis", "chapters")
+      mkdirSync(projDir, { recursive: true })
+      writeFileSync(join(projDir, ".progress.json"), "{}")
+      const found = findActiveProject(tmp)
+      console.assert(found === join(tmp, "my-project"), `pass-2 failed: ${found}`)
+
+      // Pass 1: cwd IS the project (user ran /poiesis from inside it)
+      const insideFound = findActiveProject(join(tmp, "my-project"))
+      console.assert(insideFound === join(tmp, "my-project"), `pass-1 failed: ${insideFound}`)
+
+      // null when nothing found
+      const empty = join(tmpdir(), `poiesis-empty-${Date.now()}`)
+      mkdirSync(empty)
+      console.assert(findActiveProject(empty) === null, "should return null for empty dir")
+
+      // chapterState round-trip
+      writeChapterState(join(tmp, "my-project"), 1, { step: "theory", prereqResult: "primed" })
+      const st = readChapterState(join(tmp, "my-project"), 1)
+      console.assert(st?.step === "theory", `state step not persisted: ${st?.step}`)
+      console.assert(
+        st?.prereqResult === "primed",
+        `state prereqResult not persisted: ${st?.prereqResult}`
+      )
+      console.assert(
+        st?.testsFile === null,
+        `state testsFile should default null: ${st?.testsFile}`
+      )
+      // patch merges, does not clobber existing fields
+      writeChapterState(join(tmp, "my-project"), 1, { step: "plan" })
+      const st2 = readChapterState(join(tmp, "my-project"), 1)
+      console.assert(st2?.step === "plan", `patched step failed: ${st2?.step}`)
+      console.assert(
+        st2?.prereqResult === "primed",
+        `prereqResult should survive patch: ${st2?.prereqResult}`
+      )
+
+      rmSync(tmp, { recursive: true })
+      rmSync(empty, { recursive: true })
+      console.log("utils.ts: ok")
+    })
+  })
+}