aiwcli 0.15.5 → 0.17.0

package/dist/templates/{_shared → core}/lib-ts/context/context-store.ts

@@ -8,9 +8,9 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { atomicWrite } from "../base/atomic-write.js";
+import { atomicWrite } from "../runtime/atomic-write.js";
 import {
   getContextDir,
   getContextsDir,
@@ -19,14 +19,18 @@ import {
   getArchiveContextDir,
   getArchiveIndexPath,
   validateContextId,
-} from "../base/constants.js";
-import { logInfo, logWarn, logError, setContextPath } from "../base/logger.js";
-import { readStateJson, writeStateJson } from "../base/state-io.js";
-import { nowIso, generateContextId } from "../base/utils.js";
+} from "../runtime/constants.js";
+import { logInfo, logWarn, logError, setContextPath } from "../runtime/logger.js";
+import { readStateJson, writeStateJson } from "../runtime/state-io.js";
+import { nowIso, generateContextId } from "../runtime/utils.js";
+import { IndexFileSchema } from "../schemas.js";
 import type { ContextState, IndexFile, IndexEntry, Mode } from "../types.js";
 
 const INDEX_VERSION = "3.0";
 
+// Module-level index cache — safe because each hook is a separate bun process
+let _indexCache: IndexFile | null = null;
+
 // ---------------------------------------------------------------------------
 // Public utilities
 // ---------------------------------------------------------------------------
@@ -73,25 +77,37 @@ export function determineArtifactType(
 // ---------------------------------------------------------------------------
 
 function loadIndex(projectRoot?: string): IndexFile {
+  if (_indexCache) return _indexCache;
   const indexPath = getIndexPath(projectRoot);
   if (fs.existsSync(indexPath)) {
     try {
-      const raw = fs.readFileSync(indexPath, "utf-8");
-      return JSON.parse(raw) as IndexFile;
-    } catch (error: any) {
+      const raw = fs.readFileSync(indexPath, "utf8");
+      const data = JSON.parse(raw);
+      const validated = IndexFileSchema.safeParse(data);
+      if (!validated.success) {
+        logWarn("context_store", `Index schema validation failed, recreating: ${validated.error.message}`);
+      } else {
+        _indexCache = data as IndexFile;
+        return _indexCache;
+      }
+    } catch (error: unknown) {
       logWarn("context_store", `Failed to read index, recreating: ${error}`);
     }
   }
-  return { version: INDEX_VERSION, updated_at: nowIso(), sessions: {}, contexts: {} };
+  const fresh: IndexFile = { version: INDEX_VERSION, updated_at: nowIso(), sessions: {}, contexts: {} };
+  _indexCache = fresh;
+  return fresh;
 }
 
 function saveIndex(index: IndexFile, projectRoot?: string): boolean {
   index.updated_at = nowIso();
   const content = JSON.stringify(index, null, 2);
-  const [success, error] = atomicWrite(getIndexPath(projectRoot), content);
+  // fsync: false — index.json is reconstructable by scanning _output/contexts/
+  const [success, error] = atomicWrite(getIndexPath(projectRoot), content, 2, [500, 1000], false);
   if (!success) {
     logWarn("context_store", `Failed to write index: ${error}`);
   }
+  _indexCache = index;
   return success;
 }
 
@@ -111,7 +127,7 @@ function migrateContextJson(contextId: string, projectRoot?: string): ContextSta
   if (!fs.existsSync(legacyPath)) return null;
 
   try {
-    const data = JSON.parse(fs.readFileSync(legacyPath, "utf-8"));
+    const data = JSON.parse(fs.readFileSync(legacyPath, "utf8"));
     const inFlight = data.in_flight ?? {};
     const oldMode = inFlight.mode ?? "none";
     const MODE_MIGRATION: Record<string, string> = {
@@ -149,7 +165,7 @@ function migrateContextJson(contextId: string, projectRoot?: string): ContextSta
       last_session: null,
       tasks: [],
     };
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("context_store", `Failed to migrate context.json for '${contextId}': ${error}`);
     return null;
   }
@@ -304,11 +320,31 @@ export function getAllContexts(
   const ctxMap = index.contexts;
 
   if (ctxMap && typeof ctxMap === "object" && Object.keys(ctxMap).length > 0) {
+    const orphanIds: string[] = [];
     for (const cid of Object.keys(ctxMap)) {
       const state = loadState(cid, projectRoot);
       if (state && (!status || state.status === status)) {
         results.push(state);
+      } else if (!state) {
+        orphanIds.push(cid);
+      }
+    }
+
+    if (orphanIds.length > 0) {
+      logWarn(
+        "context_store",
+        `Index references ${orphanIds.length} missing context(s): ${orphanIds.join(", ")}. Auto-repairing index.`
+      );
+      const idx = loadIndex(projectRoot);
+      for (const cid of orphanIds) {
+        delete idx.contexts[cid];
+        if (idx.sessions) {
+          for (const [sid, target] of Object.entries(idx.sessions)) {
+            if (target === cid) delete idx.sessions[sid];
+          }
+        }
       }
+      saveIndex(idx, projectRoot);
     }
   } else {
     // Fallback: scan folders
@@ -493,7 +529,7 @@ export function maybeActivate(
 
   if (state.mode === "idle" || state.mode === "has_staged_work") {
     const oldMode = state.mode;
-    const opts: Record<string, any> = {};
+    const opts: Record<string, unknown> = {};
     if (oldMode === "has_staged_work") opts.work_consumed = true; // CHANGED: unified flag
     updateMode(contextId, "active", projectRoot, opts);
     logInfo(
@@ -560,7 +596,7 @@ export function archiveContext(contextId: string, projectRoot?: string): Context
 
   try {
     fs.renameSync(sourceDir, archiveDest);
-  } catch (error: any) {
+  } catch (error: unknown) {
     logError("context_store", `Failed to move context to archive: ${error}`);
     return null;
   }
@@ -650,8 +686,8 @@ function updateArchiveIndex(state: ContextState, projectRoot?: string): boolean
 
   if (fs.existsSync(archiveIndexPath)) {
     try {
-      archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf-8"));
-    } catch (error_: any) {
+      archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf8"));
+    } catch (error_: unknown) {
       logWarn("context_store", `Failed to read archive index, recreating: ${error_}`);
     }
   }
@@ -679,7 +715,7 @@ function restoreFromArchive(contextId: string, projectRoot?: string): ContextSta
 
   try {
     fs.renameSync(archiveDir, activeDir);
-  } catch (error: any) {
+  } catch (error: unknown) {
     logError("context_store", `Failed to restore context from archive: ${error}`);
     return null;
   }
@@ -697,7 +733,7 @@ function removeFromArchiveIndex(contextId: string, projectRoot?: string): boolea
   if (!fs.existsSync(archiveIndexPath)) return true;
 
   try {
-    const archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf-8")) as IndexFile;
+    const archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf8")) as IndexFile;
     if (archiveIndex.contexts[contextId]) {
       delete archiveIndex.contexts[contextId];
       archiveIndex.updated_at = nowIso();
@@ -709,8 +745,11 @@ function removeFromArchiveIndex(contextId: string, projectRoot?: string): boolea
       }
     }
     return true;
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("context_store", `Failed to read archive index: ${error}`);
     return false;
   }
 }
+
+
+

package/dist/templates/{_shared → core}/lib-ts/context/plan-manager.ts

@@ -10,12 +10,12 @@
 
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { atomicWrite } from "../base/atomic-write.js";
-import { getContextPlansDir, sanitizeTitle } from "../base/constants.js";
-import { logDebug, logInfo, logWarn, logError } from "../base/logger.js";
-import { generateSlug } from "../base/utils.js";
+import { atomicWrite } from "../runtime/atomic-write.js";
+import { getContextPlansDir, sanitizeTitle } from "../runtime/constants.js";
+import { logDebug, logInfo, logWarn, logError } from "../runtime/logger.js";
+import { generateSlug } from "../runtime/utils.js";
 
 // ---------------------------------------------------------------------------
 // Plan archival
@@ -42,14 +42,14 @@ export function archivePlan(
 
   let content: string;
   try {
-    content = fs.readFileSync(planPath, "utf-8");
-  } catch (error_: any) {
+    content = fs.readFileSync(planPath, "utf8");
+  } catch (error_: unknown) {
     logError("plan_manager", `Failed to read plan: ${error_}`);
     return [null, null, null];
   }
 
   // Compute hash and signature
-  const planHash = crypto.createHash("sha256").update(content, "utf-8").digest("hex").slice(0, 12);
+  const planHash = crypto.createHash("sha256").update(content, "utf8").digest("hex").slice(0, 12);
   const planSignature = content.slice(0, 200);
 
   // Ensure plans directory exists
@@ -144,12 +144,12 @@ export function findLatestPlan(
   try {
     // Dynamic import to avoid circular dependency at module level
     // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef -- dynamic require to avoid circular dependency
-    const stateIo = require("../base/state-io.js");
+    const stateIo = require("../runtime/state-io.js");
     const state = stateIo.readStateJson(contextId, projectRoot);
     if (state?.plan_path && fs.existsSync(state.plan_path)) {
       return state.plan_path;
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("plan_manager", `Failed to check state.json plan_path: ${error}`);
   }
 
@@ -249,8 +249,8 @@ export function findPlanPathInTranscript(transcriptPath: string): string | null
 
   let lines: string[];
   try {
-    lines = fs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
-  } catch (error: any) {
+    lines = fs.readFileSync(transcriptPath, "utf8").split(/\r?\n/);
+  } catch (error: unknown) {
     logWarn("plan_manager", `Failed to read transcript: ${error}`);
     return null;
   }
@@ -259,16 +259,17 @@ export function findPlanPathInTranscript(transcriptPath: string): string | null
     const line = lines[i]!.trim();
     if (!line) continue;
 
-    let data: any;
+    let data: unknown;
     try {
       data = JSON.parse(line);
     } catch {
       continue;
     }
 
-    let contentArr: any;
+    let contentArr: unknown;
     try {
-      contentArr = data.message?.content;
+      const message = (data as { message?: { content?: unknown } }).message;
+      contentArr = message?.content;
     } catch {
       continue;
     }
@@ -311,3 +312,6 @@ export function extractPlanPathFromResult(toolResult: string): string | null {
   const match = toolResult.match(/Your plan has been saved to:\s*(.+\.md)/);
   return match ? match[1]!.trim() : null;
 }
+
+
+

package/dist/templates/{_shared → core}/lib-ts/context/task-tracker.ts

@@ -6,9 +6,9 @@
  * Uses state-io for I/O to avoid circular imports with context-store.
  */
 
-import { logWarn } from "../base/logger.js";
-import { readStateJson, toDict as _toDict, writeStateJson } from "../base/state-io.js";
-import { nowIso } from "../base/utils.js";
+import { logWarn } from "../runtime/logger.js";
+import { readStateJson, toDict as _toDict, writeStateJson } from "../runtime/state-io.js";
+import { nowIso } from "../runtime/utils.js";
 import type { ContextState as _ContextState, Task } from "../types.js";
 
 // ---------------------------------------------------------------------------

package/dist/templates/core/lib-ts/hooks/context-monitor-logic.ts

@@ -0,0 +1,32 @@
+export const CONTEXT_WARNING_30 = "## Context Window: ~30% Remaining\n\n" +
+  "This session is approaching its context limit. Consider:\n\n" +
+  "- Completing your current task, then pausing for the user to decide next steps\n" +
+  "- If significant work remains, mention that `/aiwcli-shared:handoff` can capture progress " +
+  "for a fresh session\n\n" +
+  "Do not rush or cut corners — finish the current task properly. " +
+  "Just be aware that starting large new tasks may not complete before context runs out.";
+
+export const CONTEXT_WARNING_15 = "## Context Window: ~15% Remaining — Wrap Up Now\n\n" +
+  "Context is critically low. After completing your current step:\n\n" +
+  "1. **Stop taking on new work**\n" +
+  "2. Summarize what was accomplished and what remains\n" +
+  "3. Offer to run `/aiwcli-shared:handoff` so progress transfers to a fresh session\n\n" +
+  "Do not start new multi-step tasks. Focus on clean closure.";
+
+const WARNING_THRESHOLDS = [
+  { pct: 15, msg: CONTEXT_WARNING_15 },
+  { pct: 30, msg: CONTEXT_WARNING_30 },
+];
+
+export function selectWarningMessage(
+  pctRemaining: number,
+  alreadyFired: number[],
+): { pct: number; msg: string } | null {
+  for (const warning of WARNING_THRESHOLDS) {
+    if (pctRemaining <= warning.pct && !alreadyFired.includes(warning.pct)) {
+      return warning;
+    }
+  }
+
+  return null;
+}