astrocode-workflow 0.1.53 → 0.1.55

package/dist/config/schema.d.ts

@@ -172,6 +172,12 @@ export declare const AstrocodeConfigSchema: z.ZodDefault<z.ZodObject<{
             idle_prompt_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>>;
+    inject: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        scope_allowlist: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        type_allowlist: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        max_per_turn: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>>;
 export type AstrocodeConfig = z.infer<typeof AstrocodeConfigSchema>;
 export {};

package/dist/config/schema.js

@@ -161,6 +161,15 @@ const GitSchema = z.object({
     commit_message_template: z.string().default("astro: {{story_key}} {{title}}"),
     persist_diff_artifacts: z.boolean().default(true),
 }).partial().default({});
+const InjectSchema = z
+    .object({
+    enabled: z.boolean().default(true),
+    scope_allowlist: z.array(z.string()).default(["repo", "global"]),
+    type_allowlist: z.array(z.string()).default(["note", "policy"]),
+    max_per_turn: z.number().int().positive().default(5),
+})
+    .partial()
+    .default({});
 const UiSchema = z
     .object({
     toasts: ToastsSchema,
@@ -196,4 +205,5 @@ export const AstrocodeConfigSchema = z.object({
     permissions: PermissionsSchema,
     git: GitSchema,
     ui: UiSchema,
+    inject: InjectSchema,
 }).partial().default({});

package/dist/hooks/inject-provider.d.ts

@@ -0,0 +1,14 @@
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+type ChatMessageInput = {
+    sessionID: string;
+    agent: string;
+};
+export declare function createInjectProvider(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): {
+    onChatMessage(input: ChatMessageInput): Promise<void>;
+};
+export {};

package/dist/hooks/inject-provider.js

@@ -0,0 +1,57 @@
+import { selectEligibleInjects } from "../tools/injects";
+import { injectChatPrompt } from "../ui/inject";
+import { nowISO } from "../shared/time";
+export function createInjectProvider(opts) {
+    const { ctx, config, db } = opts;
+    // Cache to avoid re-injecting the same injects repeatedly
+    const injectedCache = new Map();
+    function shouldSkipInject(injectId, nowMs) {
+        const lastInjected = injectedCache.get(injectId);
+        if (!lastInjected)
+            return false;
+        // Skip if injected within the last 5 minutes (configurable?)
+        const cooldownMs = 5 * 60 * 1000;
+        return nowMs - lastInjected < cooldownMs;
+    }
+    function markInjected(injectId, nowMs) {
+        injectedCache.set(injectId, nowMs);
+    }
+    async function injectEligibleInjects(sessionId) {
+        const now = nowISO();
+        const nowMs = Date.now();
+        // Get eligible injects - use allowlists from config or defaults
+        const scopeAllowlist = config.inject?.scope_allowlist ?? ["repo", "global"];
+        const typeAllowlist = config.inject?.type_allowlist ?? ["note", "policy"];
+        const eligibleInjects = selectEligibleInjects(db, {
+            nowIso: now,
+            scopeAllowlist,
+            typeAllowlist,
+            limit: config.inject?.max_per_turn ?? 5,
+        });
+        if (eligibleInjects.length === 0)
+            return;
+        // Inject each eligible inject, skipping recently injected ones
+        for (const inject of eligibleInjects) {
+            if (shouldSkipInject(inject.inject_id, nowMs))
+                continue;
+            // Format as injection message
+            const formattedText = `[Inject: ${inject.title}]\n\n${inject.body_md}`;
+            await injectChatPrompt({
+                ctx,
+                sessionId,
+                text: formattedText,
+                agent: "Astrocode"
+            });
+            markInjected(inject.inject_id, nowMs);
+        }
+    }
+    // Public hook handlers
+    return {
+        async onChatMessage(input) {
+            if (!config.inject?.enabled)
+                return;
+            // Inject eligible injects before processing the user's message
+            await injectEligibleInjects(input.sessionID);
+        },
+    };
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { getAstroPaths, ensureAstroDirs } from "./shared/paths";
 import { createAstroTools } from "./tools";
 import { createContinuationEnforcer } from "./hooks/continuation-enforcer";
 import { createToolOutputTruncatorHook } from "./hooks/tool-output-truncator";
+import { createInjectProvider } from "./hooks/inject-provider";
 import { createToastManager } from "./ui/toasts";
 import { createAstroAgents } from "./agents/registry";
 const Astrocode = async (ctx) => {
@@ -21,6 +22,7 @@ const Astrocode = async (ctx) => {
     let configHandler = null;
     let continuation = null;
     let truncatorHook = null;
+    let injectProvider = null;
     let toasts = null;
     try {
         db = openSqlite(paths.dbPath, { busyTimeoutMs: pluginConfig.db.busy_timeout_ms });
@@ -31,6 +33,7 @@ const Astrocode = async (ctx) => {
         tools = createAstroTools({ ctx, config: pluginConfig, db, agents });
         continuation = createContinuationEnforcer({ ctx, config: pluginConfig, db });
         truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, db });
+        injectProvider = createInjectProvider({ ctx, config: pluginConfig, db });
         toasts = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
     }
     catch (e) {
@@ -46,6 +49,7 @@ const Astrocode = async (ctx) => {
         tools = createAstroTools({ ctx, config: pluginConfig, db, agents });
         continuation = null;
         truncatorHook = null;
+        injectProvider = null;
         toasts = null;
     }
     return {
@@ -80,6 +84,9 @@ const Astrocode = async (ctx) => {
             }
         },
         "chat.message": async (input, output) => {
+            if (injectProvider && !pluginConfig.disabled_hooks.includes("inject-provider")) {
+                await injectProvider.onChatMessage(input);
+            }
             if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
                 await continuation.onChatMessage(input);
             }

package/dist/tools/injects.d.ts

@@ -21,3 +21,28 @@ export declare function createAstroInjectSearchTool(opts: {
     config: AstrocodeConfig;
     db: SqliteDb;
 }): ToolDefinition;
+export type InjectRow = {
+    inject_id: string;
+    type: string;
+    title: string;
+    body_md: string;
+    tags_json: string;
+    scope: string;
+    source: string;
+    priority: number;
+    expires_at: string | null;
+    sha256: string;
+    created_at: string;
+    updated_at: string;
+};
+export declare function selectEligibleInjects(db: SqliteDb, opts: {
+    nowIso: string;
+    scopeAllowlist: string[];
+    typeAllowlist: string[];
+    limit?: number;
+}): InjectRow[];
+export declare function createAstroInjectEligibleTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/tools/injects.js

@@ -97,3 +97,43 @@ export function createAstroInjectSearchTool(opts) {
         },
     });
 }
+export function selectEligibleInjects(db, opts) {
+    const { nowIso, scopeAllowlist, typeAllowlist, limit = 50 } = opts;
+    // Build placeholders safely
+    const scopeQs = scopeAllowlist.map(() => "?").join(", ");
+    const typeQs = typeAllowlist.map(() => "?").join(", ");
+    const sql = `
+    SELECT *
+    FROM injects
+    WHERE (expires_at IS NULL OR expires_at > ?)
+      AND scope IN (${scopeQs})
+      AND type IN (${typeQs})
+    ORDER BY priority DESC, updated_at DESC
+    LIMIT ?
+  `;
+    const params = [nowIso, ...scopeAllowlist, ...typeAllowlist, limit];
+    return db.prepare(sql).all(...params);
+}
+export function createAstroInjectEligibleTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Debug: show which injects are eligible right now for injection.",
+        args: {
+            scopes_json: tool.schema.string().default('["repo","global"]'),
+            types_json: tool.schema.string().default('["note","policy"]'),
+            limit: tool.schema.number().int().positive().default(50),
+        },
+        execute: async ({ scopes_json, types_json, limit }) => {
+            const now = nowISO();
+            const scopes = JSON.parse(scopes_json);
+            const types = JSON.parse(types_json);
+            const rows = selectEligibleInjects(db, {
+                nowIso: now,
+                scopeAllowlist: scopes,
+                typeAllowlist: types,
+                limit,
+            });
+            return JSON.stringify({ now, count: rows.length, rows }, null, 2);
+        },
+    });
+}

package/dist/tools/workflow.js

@@ -10,13 +10,13 @@ import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 // Agent name mapping for case-sensitive resolution
 const STAGE_TO_AGENT_MAP = {
-    frame: "frame",
-    plan: "plan",
-    spec: "spec",
-    implement: "implement",
-    review: "review",
-    verify: "verify",
-    close: "close"
+    frame: "Frame",
+    plan: "Plan",
+    spec: "Spec",
+    implement: "Implement",
+    review: "Review",
+    verify: "Verify",
+    close: "Close"
 };
 function resolveAgentName(stageKey, config) {
     // Use configurable agent names from config, fallback to hardcoded map, then General

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/config/schema.ts

@@ -194,6 +194,16 @@ const GitSchema = z.object({
   persist_diff_artifacts: z.boolean().default(true),
 }).partial().default({});
 
+const InjectSchema = z
+  .object({
+    enabled: z.boolean().default(true),
+    scope_allowlist: z.array(z.string()).default(["repo", "global"]),
+    type_allowlist: z.array(z.string()).default(["note", "policy"]),
+    max_per_turn: z.number().int().positive().default(5),
+  })
+  .partial()
+  .default({});
+
 const UiSchema = z
   .object({
     toasts: ToastsSchema,
@@ -232,6 +242,7 @@ export const AstrocodeConfigSchema = z.object({
   permissions: PermissionsSchema,
   git: GitSchema,
   ui: UiSchema,
+  inject: InjectSchema,
 }).partial().default({});
 
 export type AstrocodeConfig = z.infer<typeof AstrocodeConfigSchema>;

package/src/hooks/inject-provider.ts

@@ -0,0 +1,79 @@
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { selectEligibleInjects } from "../tools/injects";
+import { injectChatPrompt } from "../ui/inject";
+import { nowISO } from "../shared/time";
+
+type ChatMessageInput = {
+  sessionID: string;
+  agent: string;
+};
+
+export function createInjectProvider(opts: {
+  ctx: any;
+  config: AstrocodeConfig;
+  db: SqliteDb;
+}) {
+  const { ctx, config, db } = opts;
+
+  // Cache to avoid re-injecting the same injects repeatedly
+  const injectedCache = new Map<string, number>();
+
+  function shouldSkipInject(injectId: string, nowMs: number): boolean {
+    const lastInjected = injectedCache.get(injectId);
+    if (!lastInjected) return false;
+
+    // Skip if injected within the last 5 minutes (configurable?)
+    const cooldownMs = 5 * 60 * 1000;
+    return nowMs - lastInjected < cooldownMs;
+  }
+
+  function markInjected(injectId: string, nowMs: number) {
+    injectedCache.set(injectId, nowMs);
+  }
+
+  async function injectEligibleInjects(sessionId: string) {
+    const now = nowISO();
+    const nowMs = Date.now();
+
+    // Get eligible injects - use allowlists from config or defaults
+    const scopeAllowlist = config.inject?.scope_allowlist ?? ["repo", "global"];
+    const typeAllowlist = config.inject?.type_allowlist ?? ["note", "policy"];
+
+    const eligibleInjects = selectEligibleInjects(db, {
+      nowIso: now,
+      scopeAllowlist,
+      typeAllowlist,
+      limit: config.inject?.max_per_turn ?? 5,
+    });
+
+    if (eligibleInjects.length === 0) return;
+
+    // Inject each eligible inject, skipping recently injected ones
+    for (const inject of eligibleInjects) {
+      if (shouldSkipInject(inject.inject_id, nowMs)) continue;
+
+      // Format as injection message
+      const formattedText = `[Inject: ${inject.title}]\n\n${inject.body_md}`;
+
+      await injectChatPrompt({
+        ctx,
+        sessionId,
+        text: formattedText,
+        agent: "Astrocode"
+      });
+
+      markInjected(inject.inject_id, nowMs);
+    }
+  }
+
+  // Public hook handlers
+  return {
+    async onChatMessage(input: ChatMessageInput) {
+      if (!config.inject?.enabled) return;
+
+      // Inject eligible injects before processing the user's message
+      await injectEligibleInjects(input.sessionID);
+    },
+  };
+}

package/src/index.ts

@@ -6,6 +6,7 @@ import { getAstroPaths, ensureAstroDirs } from "./shared/paths";
 import { createAstroTools } from "./tools";
 import { createContinuationEnforcer } from "./hooks/continuation-enforcer";
 import { createToolOutputTruncatorHook } from "./hooks/tool-output-truncator";
+import { createInjectProvider } from "./hooks/inject-provider";
 import { createToastManager } from "./ui/toasts";
 import { createAstroAgents } from "./agents/registry";
 import { info, warn } from "./shared/log";
@@ -25,10 +26,11 @@ const Astrocode: Plugin = async (ctx) => {
 
   let db: any = null;
   let tools: any = null;
-  let configHandler: any = null;
-  let continuation: any = null;
-  let truncatorHook: any = null;
-  let toasts: any = null;
+    let configHandler: any = null;
+    let continuation: any = null;
+    let truncatorHook: any = null;
+    let injectProvider: any = null;
+    let toasts: any = null;
 
   try {
 
@@ -41,6 +43,7 @@ const Astrocode: Plugin = async (ctx) => {
     tools = createAstroTools({ ctx, config: pluginConfig, db, agents });
     continuation = createContinuationEnforcer({ ctx, config: pluginConfig, db });
     truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, db });
+    injectProvider = createInjectProvider({ ctx, config: pluginConfig, db });
     toasts = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
   } catch (e) {
     // Database initialization failed - setup limited mode
@@ -58,6 +61,7 @@ const Astrocode: Plugin = async (ctx) => {
     tools = createAstroTools({ ctx, config: pluginConfig, db, agents });
     continuation = null;
     truncatorHook = null;
+    injectProvider = null;
     toasts = null;
   }
 
@@ -102,6 +106,9 @@ const Astrocode: Plugin = async (ctx) => {
     },
 
     "chat.message": async (input: any, output: any) => {
+      if (injectProvider && !pluginConfig.disabled_hooks.includes("inject-provider")) {
+        await injectProvider.onChatMessage(input);
+      }
       if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
         await continuation.onChatMessage(input);
       }

package/src/tools/injects.ts

@@ -106,3 +106,71 @@ export function createAstroInjectSearchTool(opts: { ctx: any; config: AstrocodeC
     },
   });
 }
+
+export type InjectRow = {
+  inject_id: string;
+  type: string;
+  title: string;
+  body_md: string;
+  tags_json: string;
+  scope: string;
+  source: string;
+  priority: number;
+  expires_at: string | null;
+  sha256: string;
+  created_at: string;
+  updated_at: string;
+};
+
+export function selectEligibleInjects(db: SqliteDb, opts: {
+  nowIso: string;
+  scopeAllowlist: string[];
+  typeAllowlist: string[];
+  limit?: number;
+}): InjectRow[] {
+  const { nowIso, scopeAllowlist, typeAllowlist, limit = 50 } = opts;
+
+  // Build placeholders safely
+  const scopeQs = scopeAllowlist.map(() => "?").join(", ");
+  const typeQs = typeAllowlist.map(() => "?").join(", ");
+
+  const sql = `
+    SELECT *
+    FROM injects
+    WHERE (expires_at IS NULL OR expires_at > ?)
+      AND scope IN (${scopeQs})
+      AND type IN (${typeQs})
+    ORDER BY priority DESC, updated_at DESC
+    LIMIT ?
+  `;
+
+  const params = [nowIso, ...scopeAllowlist, ...typeAllowlist, limit];
+  return db.prepare(sql).all(...params) as InjectRow[];
+}
+
+export function createAstroInjectEligibleTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Debug: show which injects are eligible right now for injection.",
+    args: {
+      scopes_json: tool.schema.string().default('["repo","global"]'),
+      types_json: tool.schema.string().default('["note","policy"]'),
+      limit: tool.schema.number().int().positive().default(50),
+    },
+    execute: async ({ scopes_json, types_json, limit }) => {
+      const now = nowISO();
+      const scopes = JSON.parse(scopes_json) as string[];
+      const types = JSON.parse(types_json) as string[];
+
+      const rows = selectEligibleInjects(db, {
+        nowIso: now,
+        scopeAllowlist: scopes,
+        typeAllowlist: types,
+        limit,
+      });
+
+      return JSON.stringify({ now, count: rows.length, rows }, null, 2);
+    },
+  });
+}

package/src/tools/workflow.ts

@@ -14,13 +14,13 @@ import { createToastManager } from "../ui/toasts";
 
 // Agent name mapping for case-sensitive resolution
 const STAGE_TO_AGENT_MAP: Record<string, string> = {
-  frame: "frame",
-  plan: "plan",
-  spec: "spec",
-  implement: "implement",
-  review: "review",
-  verify: "verify",
-  close: "close"
+  frame: "Frame",
+  plan: "Plan",
+  spec: "Spec",
+  implement: "Implement",
+  review: "Review",
+  verify: "Verify",
+  close: "Close"
 };
 
 function resolveAgentName(stageKey: StageKey, config: AstrocodeConfig): string {