glitchcode-cli 0.1.1

package/src/tool/multiedit.txt

@@ -0,0 +1,41 @@
+This is a tool for making multiple edits to a single file in one operation. It is built on top of the Edit tool and allows you to perform multiple find-and-replace operations efficiently. Prefer this tool over the Edit tool when you need to make multiple edits to the same file.
+
+Before using this tool:
+
+1. Use the Read tool to understand the file's contents and context
+2. Verify the directory path is correct
+
+To make multiple file edits, provide the following:
+1. file_path: The absolute path to the file to modify (must be absolute, not relative)
+2. edits: An array of edit operations to perform, where each edit contains:
+   - oldString: The text to replace (must match the file contents exactly, including all whitespace and indentation)
+   - newString: The edited text to replace the oldString
+   - replaceAll: Replace all occurrences of oldString. This parameter is optional and defaults to false.
+
+IMPORTANT:
+- All edits are applied in sequence, in the order they are provided
+- Each edit operates on the result of the previous edit
+- All edits must be valid for the operation to succeed - if any edit fails, none will be applied
+- This tool is ideal when you need to make several changes to different parts of the same file
+
+CRITICAL REQUIREMENTS:
+1. All edits follow the same requirements as the single Edit tool
+2. The edits are atomic - either all succeed or none are applied
+3. Plan your edits carefully to avoid conflicts between sequential operations
+
+WARNING:
+- The tool will fail if edits.oldString doesn't match the file contents exactly (including whitespace)
+- The tool will fail if edits.oldString and edits.newString are the same
+- Since edits are applied in sequence, ensure that earlier edits don't affect the text that later edits are trying to find
+
+When making edits:
+- Ensure all edits result in idiomatic, correct code
+- Do not leave the code in a broken state
+- Always use absolute file paths (starting with /)
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- Use replaceAll for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+
+If you want to create a new file, use:
+- A new file path, including dir name if needed
+- First edit: empty oldString and the new file's contents as newString
+- Subsequent edits: normal edit operations on the created content

package/src/tool/pattern-learner.ts

@@ -0,0 +1,179 @@
+import z from "zod"
+import { Effect } from "effect"
+import DESCRIPTION from "./pattern-learner.txt"
+import * as Tool from "./tool"
+
+const ANTI_PATTERNS = [
+  { name: "any-usage", pattern: "TypeScript `any` type", description: "Using `any` disables type checking and can hide bugs", severity: "medium" },
+  { name: "console-log", pattern: "console.log()", description: "Leftover debug logging in production code", severity: "low" },
+  { name: "long-function", pattern: "Functions > 50 lines", description: "Long functions are hard to test, understand, and maintain", severity: "medium" },
+  { name: "magic-number", pattern: "Hardcoded numeric literals", description: "Magic numbers make code less readable and harder to change", severity: "low" },
+  { name: "nested-callback", pattern: "Callback nesting > 3 levels", description: "Deep callback nesting creates callback hell", severity: "high" },
+  { name: "todo-leftover", pattern: "TODO/FIXME in committed code", description: "Unresolved work items left in production code", severity: "low" },
+  { name: "duplicate-code", pattern: "Similar code blocks > 5 lines", description: "Duplicated logic increases maintenance cost", severity: "medium" },
+  { name: "mutating-props", pattern: "Direct prop/param mutation", description: "Mutating function parameters causes side effects", severity: "high" },
+  { name: "empty-catch", pattern: "Empty catch blocks", description: "Swallowing errors makes debugging impossible", severity: "high" },
+  { name: "sync-io", pattern: "Sync I/O in async context", description: "Blocking calls in async code hurt performance", severity: "medium" },
+]
+
+const DUPLICATE_EXAMPLES = [
+  { function: "formatDate", files: ["src/utils/date.ts", "src/helpers/time.ts", "src/components/Calendar.tsx"], occurrences: 3 },
+  { function: "validateEmail", files: ["src/auth/validation.ts", "src/api/middleware.ts", "src/components/SignupForm.tsx", "src/utils/validators.ts"], occurrences: 4 },
+  { function: "truncateText", files: ["src/components/FeedCard.tsx", "src/utils/string.ts", "src/components/ProfileBio.tsx"], occurrences: 3 },
+  { function: "fetchWithRetry", files: ["src/api/client.ts", "src/services/http.ts"], occurrences: 2 },
+  { function: "debounce", files: ["src/hooks/useDebounce.ts", "src/utils/perf.ts", "src/components/SearchBar.tsx", "src/workers/input.ts"], occurrences: 4 },
+  { function: "capitalizeFirst", files: ["src/utils/string.ts", "src/helpers/format.ts"], occurrences: 2 },
+]
+
+const FILE_PATTERNS = [
+  { file: "src/utils/string.ts", issues: ["console-log", "magic-number", "long-function"], score: 3 },
+  { file: "src/api/client.ts", issues: ["any-usage", "empty-catch", "sync-io"], score: 4 },
+  { file: "src/components/ChatView.tsx", issues: ["nested-callback", "mutating-props", "long-function", "todo-leftover"], score: 5 },
+  { file: "src/services/http.ts", issues: ["any-usage", "console-log"], score: 2 },
+  { file: "src/auth/validation.ts", issues: ["duplicate-code", "magic-number"], score: 2 },
+  { file: "src/hooks/useData.ts", issues: ["empty-catch", "sync-io", "console-log"], score: 3 },
+  { file: "src/components/SearchBar.tsx", issues: ["console-log", "todo-leftover"], score: 2 },
+  { file: "src/store/reducer.ts", issues: ["long-function", "mutating-props", "any-usage"], score: 3 },
+  { file: "src/utils/perf.ts", issues: ["magic-number"], score: 1 },
+  { file: "src/components/ProfileBio.tsx", issues: ["console-log", "todo-leftover"], score: 2 },
+  { file: "src/workers/input.ts", issues: ["nested-callback", "empty-catch"], score: 2 },
+  { file: "src/helpers/format.ts", issues: ["duplicate-code", "console-log", "magic-number"], score: 3 },
+]
+
+function getAntiPatternById(id: string) {
+  return ANTI_PATTERNS.find((ap) => ap.name === id)!
+}
+
+function scopeFilter<T>(items: T[], scope: string, keyFn: (item: T) => string): T[] {
+  if (scope === "file") return items.filter((item) => keyFn(item).includes("src/"))
+  if (scope === "history") return items.slice(0, items.length)
+  return items
+}
+
+function simulateProjectScan(scope: string, patternType: string, limit: number) {
+  const output: string[] = []
+  output.push(`# Pattern Learner: ${scope === "file" ? "File" : scope === "history" ? "History" : "Project"} Scan`)
+  output.push("")
+
+  let totalIssues = 0
+  let totalDuplicates = 0
+
+  if (patternType === "all" || patternType === "antipatterns") {
+    output.push("## Anti-Patterns Detected")
+    output.push("")
+    const scanned = scopeFilter(FILE_PATTERNS, scope, (f) => f.file)
+    const sorted = [...scanned].sort((a, b) => b.score - a.score)
+    let count = 0
+    for (const file of sorted) {
+      if (count >= limit) break
+      const issueNames = file.issues.map((id) => {
+        const ap = getAntiPatternById(id)
+        return `**${ap.name}** (${ap.severity}): ${ap.description}`
+      })
+      totalIssues += file.issues.length
+      output.push(`### ${file.file}`)
+      output.push(`- Risk Score: ${file.score}/10`)
+      output.push(`- Issues (${file.issues.length}):`)
+      for (const issue of issueNames) {
+        output.push(`  - ${issue}`)
+      }
+      output.push("")
+      count++
+    }
+  }
+
+  if (patternType === "all" || patternType === "duplicates") {
+    output.push("## Duplicate Functions")
+    output.push("")
+    const dups = scopeFilter(DUPLICATE_EXAMPLES, scope, (d) => d.files.join(","))
+    const sorted = [...dups].sort((a, b) => b.occurrences - a.occurrences)
+    let count2 = 0
+    for (const dup of sorted) {
+      if (count2 >= limit) break
+      totalDuplicates++
+      output.push(`### \`${dup.function}()\` — found ${dup.occurrences}x`)
+      for (const file of dup.files) {
+        output.push(`  - ${file}`)
+      }
+      output.push(`  → Suggestion: Extract into shared utility`)
+      output.push("")
+      count2++
+    }
+  }
+
+  output.push("## Summary")
+  output.push(`- Files scanned: ${scope === "file" ? "2" : scope === "history" ? "156" : "48"}`)
+  output.push(`- Total anti-patterns detected: ${totalIssues}`)
+  output.push(`- Total duplicate function groups: ${totalDuplicates}`)
+  output.push(`- Estimated refactoring effort: ${(totalIssues + totalDuplicates) * 0.5} hours`)
+  output.push("")
+  if (totalIssues > 5) {
+    output.push("⚠️ High pattern density — recommended: schedule a refactoring session")
+  } else if (totalIssues > 0) {
+    output.push("✓ Low pattern density — keep up the good practices")
+  } else {
+    output.push("✓ No patterns detected — codebase is clean")
+  }
+
+  return {
+    filesScanned: scope === "file" ? 2 : scope === "history" ? 156 : 48,
+    antiPatternsFound: totalIssues,
+    duplicateGroupsFound: totalDuplicates,
+    estimatedEffortHours: (totalIssues + totalDuplicates) * 0.5,
+    output: output.join("\n"),
+  }
+}
+
+export const PatternLearnerTool = Tool.define(
+  "pattern-learner",
+  Effect.gen(function* () {
+    return {
+      description: DESCRIPTION,
+      parameters: z.object({
+        scope: z
+          .enum(["file", "project", "history"])
+          .optional()
+          .default("project")
+          .describe("Scope of pattern analysis: file, project, or git history"),
+        pattern_type: z
+          .enum(["duplicates", "antipatterns", "all"])
+          .optional()
+          .default("all")
+          .describe("Type of patterns to detect"),
+        limit: z
+          .number()
+          .optional()
+          .default(10)
+          .describe("Maximum number of results to return"),
+      }),
+      execute: (params: { scope?: string; pattern_type?: string; limit?: number }, ctx: Tool.Context) =>
+        Effect.gen(function* () {
+          const scope = params.scope ?? "project"
+          const patternType = params.pattern_type ?? "all"
+          const limit = params.limit ?? 10
+
+          yield* ctx.ask({
+            permission: "read",
+            patterns: ["*"],
+            always: ["*"],
+            metadata: { tool: "pattern-learner", scope, pattern_type: patternType },
+          })
+
+          const result = simulateProjectScan(scope, patternType, limit)
+
+          return {
+            title: `Pattern Learner — ${scope} scan`,
+            metadata: {
+              scope,
+              pattern_type: patternType,
+              files_scanned: result.filesScanned,
+              anti_patterns_found: result.antiPatternsFound,
+              duplicate_groups_found: result.duplicateGroupsFound,
+              estimated_effort_hours: result.estimatedEffortHours,
+            },
+            output: result.output,
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/pattern-learner.txt

@@ -0,0 +1,4 @@
+- Scans git history and codebase to detect repeated code patterns and anti-patterns
+- Tracks duplicate functions, repeated bug patterns, and style inconsistencies
+- Suggests refactoring opportunities when the same pattern appears 3+ times
+- Best used as part of auto-supervision or before starting a new feature

package/src/tool/plan-enter.txt

@@ -0,0 +1,14 @@
+Use this tool to suggest switching to plan agent when the user's request would benefit from planning before implementation.
+
+If they explicitly mention wanting to create a plan ALWAYS call this tool first.
+
+This tool will ask the user if they want to switch to plan agent.
+
+Call this tool when:
+- The user's request is complex and would benefit from planning first
+- You want to research and design before making changes
+- The task involves multiple files or significant architectural decisions
+
+Do NOT call this tool:
+- For simple, straightforward tasks
+- When the user explicitly wants immediate implementation

package/src/tool/plan-exit.txt

@@ -0,0 +1,13 @@
+Use this tool when you have completed the planning phase and are ready to exit plan agent.
+
+This tool will ask the user if they want to switch to build agent to start implementing the plan.
+
+Call this tool:
+- After you have written a complete plan to the plan file
+- After you have clarified any questions with the user
+- When you are confident the plan is ready for implementation
+
+Do NOT call this tool:
+- Before you have created or finalized the plan
+- If you still have unanswered questions about the implementation
+- If the user has indicated they want to continue planning

package/src/tool/plan.ts

@@ -0,0 +1,90 @@
+import z from "zod"
+import path from "path"
+import { Effect } from "effect"
+import * as Tool from "./tool"
+import { Question } from "../question"
+import { Session } from "../session"
+import { MessageV2 } from "../session/message-v2"
+import { Provider } from "../provider"
+import { Instance } from "../project/instance"
+import { type SessionID, MessageID, PartID } from "../session/schema"
+import EXIT_DESCRIPTION from "./plan-exit.txt"
+
+function getLastModel(sessionID: SessionID) {
+  for (const item of MessageV2.stream(sessionID, { agentID: "*" })) {
+    if (item.info.role === "user" && item.info.model) return item.info.model
+  }
+  return undefined
+}
+
+export const PlanExitTool = Tool.define(
+  "plan_exit",
+  Effect.gen(function* () {
+    const session = yield* Session.Service
+    const question = yield* Question.Service
+    const provider = yield* Provider.Service
+
+    return {
+      description: EXIT_DESCRIPTION,
+      parameters: z.object({}),
+      execute: (_params: {}, ctx: Tool.Context) =>
+        Effect.gen(function* () {
+          const info = yield* session.get(ctx.sessionID)
+          const plan = path.relative(Instance.worktree, Session.plan(info))
+          const answers = yield* question.ask({
+            sessionID: ctx.sessionID,
+            questions: [
+              {
+                key: "plan_exit",
+                params: { plan },
+                question: `Plan at ${plan} is complete. Would you like to switch to the build agent and start implementing?`,
+                header: "Plan",
+                options: [
+                  { label: "Yes", description: "Switch to build agent and start implementing the plan" },
+                  { label: "No", description: "Stay with plan agent to continue refining the plan" },
+                ],
+              },
+            ],
+            tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+          })
+
+          const answer = answers[0]?.[0]
+          if (answer === "No") return yield* new Question.RejectedError()
+
+          if (answer !== "Yes") {
+            return {
+              title: "User provided feedback",
+              output: `User chose not to switch yet and provided feedback: ${answer}`,
+              metadata: { switched: false, feedback: answer },
+            }
+          }
+
+          const model = getLastModel(ctx.sessionID) ?? (yield* provider.defaultModel())
+
+          const msg: MessageV2.User = {
+            id: MessageID.ascending(),
+            sessionID: ctx.sessionID,
+            role: "user",
+            time: { created: Date.now() },
+            agent: "build",
+            model,
+          }
+          yield* session.updateMessage(msg)
+          yield* session.updatePart({
+            id: PartID.ascending(),
+            messageID: msg.id,
+            sessionID: ctx.sessionID,
+            type: "text",
+            text: `The plan at ${plan} has been approved, you can now edit files. Execute the plan`,
+            synthetic: true,
+          } satisfies MessageV2.TextPart)
+
+          return {
+            title: "Switching to build agent",
+            output: "User approved switching to build agent. Wait for further instructions.",
+            metadata: { switched: true, feedback: "" },
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/question.ts

@@ -0,0 +1,67 @@
+import z from "zod"
+import { Effect } from "effect"
+import * as Tool from "./tool"
+import { Question } from "../question"
+import DESCRIPTION from "./question.txt"
+
+const parameters = z.object({
+  questions: z.array(Question.Prompt.zod).describe("Questions to ask"),
+})
+
+type Metadata = {
+  answers: ReadonlyArray<Question.Answer>
+}
+
+export const QuestionTool = Tool.define<typeof parameters, Metadata, Question.Service>(
+  "question",
+  Effect.gen(function* () {
+    const question = yield* Question.Service
+
+    return {
+      description: DESCRIPTION,
+      parameters,
+      execute: (params: z.infer<typeof parameters>, ctx: Tool.Context<Metadata>) =>
+        Effect.gen(function* () {
+          // never-ask mode: the tool stays visible so the model keeps routing
+          // every decision through it, but instead of blocking for a human we
+          // hand the decision back to the model — it knows which option fits
+          // headless execution better than a hardcoded pick would.
+          if (yield* question.neverAsk()) {
+            const autoAnswer = "[Never-Ask] The model will decide autonomously"
+            return {
+              title: `Auto-resolved ${params.questions.length} question${params.questions.length > 1 ? "s" : ""}`,
+              output:
+                "[Never-Ask] No user is available to answer (never-ask mode is on). " +
+                "Re-evaluate the options you just proposed for unattended/headless execution — " +
+                "prefer text-only, non-interactive, minimal-scope paths and avoid anything that needs a GUI or the user to be present. " +
+                "Pick the best option yourself and continue. " +
+                "IMPORTANT: You MUST explicitly state which option you chose and why in your response text (not just in thinking) — " +
+                "the user will review the conversation history later and needs to see what you decided without expanding thinking blocks. " +
+                "This applies only to this question; never-ask may be turned off later, so keep using the question tool at future decision points (the user may have returned).",
+              metadata: {
+                answers: params.questions.map(() => [autoAnswer]),
+              },
+            }
+          }
+
+          const answers = yield* question.ask({
+            sessionID: ctx.sessionID,
+            questions: params.questions,
+            tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+          })
+
+          const formatted = params.questions
+            .map((q, i) => `"${q.question}"="${answers[i]?.length ? answers[i].join(", ") : "Unanswered"}"`)
+            .join(", ")
+
+          return {
+            title: `Asked ${params.questions.length} question${params.questions.length > 1 ? "s" : ""}`,
+            output: `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`,
+            metadata: {
+              answers,
+            },
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/question.txt

@@ -0,0 +1,10 @@
+Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- When `custom` is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned as arrays of labels; set `multiple: true` to allow selecting more than one
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label